/** * Gets a table name for many-to-many relation * * @param string $activityTableName Activity entity table name. It is owning side of the association. * @param string $targetTableName Target entity table name. * * @return string */ public function getAssociationTableName($activityTableName, $targetTableName) { $sourceClassName = $this->extendExtension->getEntityClassByTableName($activityTableName); $targetClassName = $this->extendExtension->getEntityClassByTableName($targetTableName); $associationName = ExtendHelper::buildAssociationName($targetClassName, ActivityScope::ASSOCIATION_KIND); return $this->nameGenerator->generateManyToManyJoinTableName($sourceClassName, $associationName, $targetClassName); }
/** * @param LoggerInterface $logger * @param bool $dryRun */ protected function runActivityLists(LoggerInterface $logger, $dryRun = false) { // @todo: this workaround should be removed in BAP-9156 $this->configManager->clear(); $targetEntities = $this->provider->getTargetEntityClasses(false); $toSchema = clone $this->schema; $hasSchemaChanges = false; foreach ($targetEntities as $targetEntity) { $associationName = ExtendHelper::buildAssociationName($targetEntity, ActivityListEntityConfigDumperExtension::ASSOCIATION_KIND); $relationTableName = $this->nameGenerator->generateManyToManyJoinTableName(ActivityListEntityConfigDumperExtension::ENTITY_CLASS, $associationName, $targetEntity); if (!$toSchema->hasTable($relationTableName)) { $hasSchemaChanges = true; $this->activityListExtension->addActivityListAssociation($toSchema, $this->metadataHelper->getTableNameByEntityClass($targetEntity)); } } if ($hasSchemaChanges) { $comparator = new Comparator(); $platform = $this->connection->getDatabasePlatform(); $schemaDiff = $comparator->compare($this->schema, $toSchema); $queries = $schemaDiff->toSql($platform); foreach ($queries as $query) { $this->logQuery($logger, $query); if (!$dryRun) { $this->connection->executeQuery($query); } } } }
/** * @param $entityClassName * @param $entityId * @return QueryBuilder */ public function getBaseAssociatedNotesQB($entityClassName, $entityId) { $ids = is_array($entityId) ? $entityId : [$entityId]; $queryBuilder = $this->createQueryBuilder('note')->innerJoin($entityClassName, 'e', 'WITH', sprintf('note.%s = e', ExtendHelper::buildAssociationName($entityClassName))); $queryBuilder->where($queryBuilder->expr()->in('e.id', $ids)); return $queryBuilder; }
/** * {@inheritdoc} */ public function up(Schema $schema, QueryBag $queries) { $relationTableName = $this->nameGenerator->generateManyToManyJoinTableName('Oro\\Bundle\\EmailBundle\\Entity\\Email', ExtendHelper::buildAssociationName('OroCRM\\Bundle\\SalesBundle\\Entity\\B2bCustomer', ActivityScope::ASSOCIATION_KIND), 'OroCRM\\Bundle\\SalesBundle\\Entity\\B2bCustomer'); if (!$schema->hasTable($relationTableName)) { $this->activityExtension->addActivityAssociation($schema, 'oro_email', 'orocrm_sales_b2bcustomer'); } }
/** * Checks if the entity can has notes * * @param object $entity * @return bool */ public function isAttachmentAssociationEnabled($entity) { if (null === $entity || !is_object($entity)) { return false; } $className = ClassUtils::getClass($entity); return $this->attachmentConfigProvider->hasConfig($className) && $this->attachmentConfigProvider->getConfig($className)->is('enabled') && $this->entityConfigProvider->hasConfig(AttachmentScope::ATTACHMENT, ExtendHelper::buildAssociationName($className)); }
/** * Check if an association between a given entity type and attachments is ready to be used in a business logic. * It means that the association should exist and should not be marked as deleted. * * @param string $entityClass The target entity class * * @return bool */ protected function isAttachmentAssociationAccessible($entityClass) { $associationName = ExtendHelper::buildAssociationName($entityClass); if (!$this->configManager->hasConfig(self::ATTACHMENT_ENTITY, $associationName)) { return false; } return ExtendHelper::isFieldAccessible($this->configManager->getFieldConfig('extend', self::ATTACHMENT_ENTITY, $associationName)); }
/** * Checks if the entity can have comments * * @param object|null $entity * * @return bool */ public function isApplicable($entity) { if (!is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || !$this->securityFacade->isGranted('oro_comment_view')) { return false; } $className = ClassUtils::getClass($entity); return $this->commentConfigProvider->hasConfig($className) && $this->commentConfigProvider->getConfig($className)->is('enabled') && $this->entityConfigProvider->hasConfig(Comment::ENTITY_NAME, ExtendHelper::buildAssociationName($className)); }
/** * Checks if the entity can has notes * * @param object $entity * @return bool */ public function isNoteAssociationEnabled($entity) { if (null === $entity || !is_object($entity)) { return false; } $className = ClassUtils::getClass($entity); return $this->noteConfigProvider->hasConfig($className) && $this->noteConfigProvider->getConfig($className)->is('enabled') && $this->entityConfigProvider->hasConfig(Note::ENTITY_NAME, ExtendHelper::buildAssociationName($className)); }
/** * Check if an association between a given entity type and activity type is ready to be used in a business logic. * It means that the association should exist and should not be marked as deleted. * * @param string $entityClass The target entity class * @param string $activityClass The activity entity class * * @return bool */ protected function isActivityAssociationAccessible($entityClass, $activityClass) { $associationName = ExtendHelper::buildAssociationName($entityClass, ActivityScope::ASSOCIATION_KIND); if (!$this->configManager->hasConfig($activityClass, $associationName)) { return false; } return ExtendHelper::isFieldAccessible($this->configManager->getFieldConfig('extend', $activityClass, $associationName)); }
public function testIsNoteAssociationEnabled() { $config = new Config(new EntityConfigId('note', static::TEST_ENTITY_REFERENCE)); $config->set('enabled', true); $this->noteConfigProvider->expects($this->once())->method('hasConfig')->with(static::TEST_ENTITY_REFERENCE)->will($this->returnValue(true)); $this->noteConfigProvider->expects($this->once())->method('getConfig')->with(static::TEST_ENTITY_REFERENCE)->will($this->returnValue($config)); $this->entityConfigProvider->expects($this->once())->method('hasConfig')->with(Note::ENTITY_NAME, ExtendHelper::buildAssociationName(static::TEST_ENTITY_REFERENCE))->will($this->returnValue(true)); $this->assertTrue($this->filter->isNoteAssociationEnabled(new TestEntity(1))); }
public function testIsAttachmentAssociationEnabled() { $config = new Config(new EntityConfigId('attachment', 'stdClass')); $config->set('enabled', true); $this->attachmentConfigProvider->expects($this->once())->method('hasConfig')->with('stdClass')->will($this->returnValue(true)); $this->attachmentConfigProvider->expects($this->once())->method('getConfig')->with('stdClass')->will($this->returnValue($config)); $this->entityConfigProvider->expects($this->once())->method('hasConfig')->with(AttachmentScope::ATTACHMENT, ExtendHelper::buildAssociationName('stdClass'))->will($this->returnValue(true)); $this->assertTrue($this->filter->isAttachmentAssociationEnabled(new \stdClass())); }
public function testGenerate() { $schema = ['relationData' => [['field_id' => new FieldConfigId('extend', 'Test\\Entity', ExtendHelper::buildAssociationName('Test\\TargetEntity1', ActivityScope::ASSOCIATION_KIND), 'manyToMany'), 'target_entity' => 'Test\\TargetEntity1'], ['field_id' => new FieldConfigId('extend', 'Test\\Entity', ExtendHelper::buildAssociationName('Test\\TargetEntity2', ActivityScope::ASSOCIATION_KIND), 'manyToMany'), 'target_entity' => 'Test\\TargetEntity2'], ['field_id' => new FieldConfigId('extend', 'Test\\Entity', ExtendHelper::buildAssociationName('Test\\TargetEntity3', ActivityScope::ASSOCIATION_KIND), 'manyToOne'), 'target_entity' => 'Test\\TargetEntity3'], ['field_id' => new FieldConfigId('extend', 'Test\\Entity', 'testField', 'manyToMany'), 'target_entity' => 'Test\\TargetEntity4']]]; $class = PhpClass::create('Test\\Entity'); $this->extension->generate($schema, $class); $strategy = new DefaultGeneratorStrategy(); $classBody = $strategy->generate($class); $expectedBody = file_get_contents(__DIR__ . '/Fixtures/generationResult.txt'); $this->assertEquals(trim($expectedBody), $classBody); }
public function testIsApplicable() { $config = new Config(new EntityConfigId('comment', static::TEST_ENTITY_REFERENCE)); $config->set('enabled', true); $this->securityFacade->expects($this->once())->method('isGranted')->with('oro_comment_view')->willReturn(true); $this->commentConfigProvider->expects($this->once())->method('hasConfig')->with(static::TEST_ENTITY_REFERENCE)->will($this->returnValue(true)); $this->commentConfigProvider->expects($this->once())->method('getConfig')->with(static::TEST_ENTITY_REFERENCE)->will($this->returnValue($config)); $this->entityConfigProvider->expects($this->once())->method('hasConfig')->with(Comment::ENTITY_NAME, ExtendHelper::buildAssociationName(static::TEST_ENTITY_REFERENCE))->will($this->returnValue(true)); $this->assertTrue($this->filter->isApplicable(new TestEntity())); }
/** * Adds the association between the target table and the visit table * * @param Schema $schema * @param string $targetTableName Target entity table name * @param string $targetColumnName A column name is used to show related entity */ public function addIdentifierAssociation(Schema $schema, $targetTableName, $targetColumnName = null) { $visitTable = $schema->getTable(self::VISIT_TABLE_NAME); $targetTable = $schema->getTable($targetTableName); if (empty($targetColumnName)) { $primaryKeyColumns = $targetTable->getPrimaryKeyColumns(); $targetColumnName = array_shift($primaryKeyColumns); } $associationName = ExtendHelper::buildAssociationName($this->extendExtension->getEntityClassByTableName($targetTableName), self::ASSOCIATION_KIND); $this->extendExtension->addManyToOneRelation($schema, $visitTable, $associationName, $targetTable, $targetColumnName); }
/** * @param string $entityClassName * @param mixed $entityId * @param int|null $page * @param int|null $limit * * @return QueryBuilder */ public function getAssociatedNotesQueryBuilder($entityClassName, $entityId, $page = null, $limit = null) { $qb = $this->createQueryBuilder('note')->select('partial note.{id, message, owner, createdAt, updatedBy, updatedAt}, c, u')->innerJoin($entityClassName, 'e', 'WITH', sprintf('note.%s = e', ExtendHelper::buildAssociationName($entityClassName)))->leftJoin('note.owner', 'c')->leftJoin('note.updatedBy', 'u')->where('e.id = :entity_id')->setParameter('entity_id', $entityId); if (null !== $page) { $qb->setFirstResult($this->getOffset($page) * $limit); } if (null !== $limit) { $qb->setMaxResults($limit); } return $qb; }
/** * @param EntityManager $em * @param object $target * @param integer $skipId * @param string $direction * * @return Call */ protected function getLastActivity(EntityManager $em, $target, $skipId, $direction = null) { $qb = $em->getRepository('OroCRM\\Bundle\\CallBundle\\Entity\\Call')->createQueryBuilder('call')->select('call')->innerJoin(sprintf('call.%s', ExtendHelper::buildAssociationName(ClassUtils::getClass($target), ActivityScope::ASSOCIATION_KIND)), 'target')->andWhere('target = :target')->orderBy('call.callDateTime', 'DESC')->setMaxResults(1)->setParameter('target', $target->getId()); if ($skipId) { $qb->andWhere('call.id <> :skipId')->setParameter('skipId', $skipId); } if ($direction) { $qb->join('call.direction', 'direction')->andWhere('direction.name = :direction')->setParameter('direction', $direction); } return $qb->getQuery()->getOneOrNullResult(); }
/** * {@inheritdoc} */ public function isIgnoredRelation(ClassMetadata $metadata, $associationName) { if ($metadata->name !== 'Oro\\Bundle\\AttachmentBundle\\Entity\\Attachment') { return false; } $mapping = $metadata->getAssociationMapping($associationName); if (!$mapping['isOwningSide'] || !($mapping['type'] & ClassMetadata::MANY_TO_ONE)) { return false; } return $associationName === ExtendHelper::buildAssociationName($mapping['targetEntity']); }
/** * {@inheritdoc} */ public function isIgnoredRelation(ClassMetadata $metadata, $associationName) { if ($metadata->name !== 'Oro\\Bundle\\TrackingBundle\\Entity\\TrackingVisit') { return false; } $mapping = $metadata->getAssociationMapping($associationName); if (!$mapping['isOwningSide'] || !($mapping['type'] & ClassMetadata::MANY_TO_ONE)) { return false; } $identifierEventAssociationName = ExtendHelper::buildAssociationName($mapping['targetEntity'], IdentifierEventExtension::ASSOCIATION_KIND); return $associationName === $identifierEventAssociationName; }
/** * Adds the association between the given table and the activity list table * * @param Schema $schema * @param string $targetTableName Target entity table name */ public function addActivityListAssociation(Schema $schema, $targetTableName) { $targetTable = $schema->getTable($targetTableName); // Column names are used to show a title of target entity $targetTitleColumnNames = $targetTable->getPrimaryKeyColumns(); // Column names are used to show detailed info about target entity $targetDetailedColumnNames = $targetTable->getPrimaryKeyColumns(); // Column names are used to show target entity in a grid $targetGridColumnNames = $targetTable->getPrimaryKeyColumns(); $associationName = ExtendHelper::buildAssociationName($this->extendExtension->getEntityClassByTableName($targetTableName), ActivityListEntityConfigDumperExtension::ASSOCIATION_KIND); $this->extendExtension->addManyToManyRelation($schema, $schema->getTable('oro_activity_list'), $associationName, $targetTable, $targetTitleColumnNames, $targetDetailedColumnNames, $targetGridColumnNames, ['extend' => ['without_default' => true]]); }
/** * @param object $entity * * @return Attachment[] */ public function getEntityAttachments($entity) { $entityClass = ClassUtils::getClass($entity); if ($this->attachmentAssociationHelper->isAttachmentAssociationEnabled($entityClass)) { $fieldName = ExtendHelper::buildAssociationName($entityClass); $repo = $this->em->getRepository('OroAttachmentBundle:Attachment'); $qb = $repo->createQueryBuilder('a'); $qb->leftJoin('a.' . $fieldName, 'entity')->where('entity.id = :entityId')->setParameter('entityId', $entity->getId()); return $qb->getQuery()->getResult(); } return []; }
/** * @param string $sourceEntityClass * @param string $targetEntityClass * @param string $associationKind */ public function createManyToOneAssociation($sourceEntityClass, $targetEntityClass, $associationKind) { $relationName = ExtendHelper::buildAssociationName($targetEntityClass, $associationKind); $entityConfigProvider = $this->configManager->getProvider('entity'); $targetEntityConfig = $entityConfigProvider->getConfig($targetEntityClass); $label = $targetEntityConfig->get('label', false, ConfigHelper::getTranslationKey('entity', 'label', $targetEntityClass, $relationName)); $description = ConfigHelper::getTranslationKey('entity', 'description', $targetEntityClass, $relationName); $targetEntityPrimaryKeyColumns = $this->getPrimaryKeyColumnNames($targetEntityClass); $targetFieldName = array_shift($targetEntityPrimaryKeyColumns); // add relation to owning entity $this->relationBuilder->addManyToOneRelation($this->configManager->getProvider('extend')->getConfig($sourceEntityClass), $targetEntityClass, $relationName, $targetFieldName, ['entity' => ['label' => $label, 'description' => $description], 'view' => ['is_displayable' => false], 'form' => ['is_enabled' => false]]); }
/** * Adds the association between the target table and the note table * * @param Schema $schema * @param string $targetTableName Target entity table name * @param string $targetColumnName A column name is used to show related entity */ public function addNoteAssociation(Schema $schema, $targetTableName, $targetColumnName = null) { $noteTable = $schema->getTable(self::NOTE_TABLE_NAME); $targetTable = $schema->getTable($targetTableName); if (empty($targetColumnName)) { $primaryKeyColumns = $targetTable->getPrimaryKeyColumns(); $targetColumnName = array_shift($primaryKeyColumns); } $options = new OroOptions(); $options->set('note', 'enabled', true); $targetTable->addOption(OroOptions::KEY, $options); $associationName = ExtendHelper::buildAssociationName($this->extendExtension->getEntityClassByTableName($targetTableName)); $this->extendExtension->addManyToOneRelation($schema, $noteTable, $associationName, $targetTable, $targetColumnName); }
public function testIsNoteAssociationEnabledForEnabledButNotAccessibleAssociation() { $entityClass = 'Test\\Entity'; $config = new Config(new EntityConfigId('note', $entityClass)); $config->set('enabled', true); $associationName = ExtendHelper::buildAssociationName($entityClass); $associationConfig = new Config(new FieldConfigId('extend', NoteAssociationHelper::NOTE_ENTITY, $associationName)); $associationConfig->set('is_extend', true); $associationConfig->set('state', ExtendScope::STATE_NEW); $this->configManager->expects($this->exactly(2))->method('hasConfig')->willReturnMap([[$entityClass, null, true], [NoteAssociationHelper::NOTE_ENTITY, $associationName, true]]); $this->configManager->expects($this->once())->method('getEntityConfig')->with('note', $entityClass)->willReturn($config); $this->configManager->expects($this->once())->method('getFieldConfig')->with('extend', NoteAssociationHelper::NOTE_ENTITY, $associationName)->willReturn($associationConfig); $this->assertFalse($this->noteAssociationHelper->isNoteAssociationEnabled($entityClass)); }
/** * Adds the association between the target table and the attachment table * * @param Schema $schema * @param string $targetTableName Target entity table name * @param string[] $allowedMimeTypes The list of allowed MIME types * @param int $maxFileSize Max allowed file size in megabytes */ public function addAttachmentAssociation(Schema $schema, $targetTableName, array $allowedMimeTypes = [], $maxFileSize = 1) { $noteTable = $schema->getTable(self::ATTACHMENT_ASSOCIATION_TABLE_NAME); $targetTable = $schema->getTable($targetTableName); $primaryKeyColumns = $targetTable->getPrimaryKeyColumns(); $targetColumnName = array_shift($primaryKeyColumns); $options = new OroOptions(); $options->set('attachment', 'enabled', true); $options->set('attachment', 'maxsize', $maxFileSize); $options->set('attachment', 'mimetypes', implode("\n", $allowedMimeTypes)); $targetTable->addOption(OroOptions::KEY, $options); $associationName = ExtendHelper::buildAssociationName($this->extendExtension->getEntityClassByTableName($targetTableName)); $this->extendExtension->addManyToOneRelation($schema, $noteTable, $associationName, $targetTable, $targetColumnName); }
/** * @param string $sourceEntityClass * @param string $targetEntityClass * @param string $associationKind */ public function createManyToOneAssociation($sourceEntityClass, $targetEntityClass, $associationKind) { $relationName = ExtendHelper::buildAssociationName($targetEntityClass, $associationKind); $extendConfigProvider = $this->configManager->getProvider('extend'); $targetEntityPrimaryKeyColumns = $this->getPrimaryKeyColumnNames($targetEntityClass); $targetFieldName = reset($targetEntityPrimaryKeyColumns); // add relation to owning entity $this->relationBuilder->addManyToOneRelation($extendConfigProvider->getConfig($sourceEntityClass), $targetEntityClass, $relationName, $targetFieldName); // update attributes for new association $fieldConfig = $extendConfigProvider->getConfig($sourceEntityClass, $relationName); if ($fieldConfig->is('state', ExtendScope::STATE_NEW)) { $targetEntityConfig = $this->configManager->getProvider('entity')->getConfig($targetEntityClass); $this->relationBuilder->updateFieldConfigs($sourceEntityClass, $relationName, ['entity' => ['label' => $this->getAssociationLabel('label', $sourceEntityClass, $relationName, $targetEntityConfig), 'description' => $this->getAssociationLabel('description', $sourceEntityClass, $relationName, $targetEntityConfig)], 'view' => ['is_displayable' => false], 'form' => ['is_enabled' => false]]); } }
/** * @param EntityManager $em * @param object $target * @param integer $skipId * @param string $direction * * @return Email */ protected function getLastActivity(EntityManager $em, $target, $skipId = null, $direction = null) { $qb = $em->getRepository('Oro\\Bundle\\EmailBundle\\Entity\\Email')->createQueryBuilder('email')->select('email')->innerJoin(sprintf('email.%s', ExtendHelper::buildAssociationName(ClassUtils::getClass($target), ActivityScope::ASSOCIATION_KIND)), 'target')->andWhere('target = :target')->orderBy('email.sentAt', 'DESC')->setMaxResults(1)->setParameter('target', $target); if ($skipId) { $qb->andWhere('email.id <> :skipId')->setParameter('skipId', $skipId); } if ($direction) { $operator = '!='; if ($direction === DirectionProviderInterface::DIRECTION_OUTGOING) { $operator = '='; } $qb->join('email.fromEmailAddress', 'fromEmailAddress')->andWhere('fromEmailAddress.email ' . $operator . ':email')->setParameter('email', $target->getEmail()); } return $qb->getQuery()->getOneOrNullResult(); }
/** * {@inheritdoc} */ public function isIgnoredRelation(ClassMetadata $metadata, $associationName) { if (!$this->configManager->hasConfig($metadata->name, $associationName)) { return false; } $groups = $this->configManager->getEntityConfig('grouping', $metadata->name)->get('groups'); if (empty($groups) || !in_array(ActivityScope::GROUP_ACTIVITY, $groups, true)) { return false; } $mapping = $metadata->getAssociationMapping($associationName); if (!$mapping['isOwningSide'] || !($mapping['type'] & ClassMetadata::MANY_TO_MANY)) { return false; } $activityAssociationName = ExtendHelper::buildAssociationName($mapping['targetEntity'], ActivityScope::ASSOCIATION_KIND); return $associationName === $activityAssociationName; }
/** * Adds the association between the given table and the table contains activity records * * The activity entity must be included in 'activity' group ('groups' attribute of 'grouping' scope) * * @param Schema $schema * @param string $activityTableName Activity entity table name. It is owning side of the association * @param string $targetTableName Target entity table name * @param bool $immutable Set TRUE to prohibit disabling the activity association from UI */ public function addActivityAssociation(Schema $schema, $activityTableName, $targetTableName, $immutable = false) { $targetTable = $schema->getTable($targetTableName); // Column names are used to show a title of target entity $targetTitleColumnNames = $targetTable->getPrimaryKeyColumns(); // Column names are used to show detailed info about target entity $targetDetailedColumnNames = $targetTable->getPrimaryKeyColumns(); // Column names are used to show target entity in a grid $targetGridColumnNames = $targetTable->getPrimaryKeyColumns(); $activityClassName = $this->extendExtension->getEntityClassByTableName($activityTableName); $options = new OroOptions(); $options->append('activity', 'activities', $activityClassName); if ($immutable) { $options->append('activity', 'immutable', $activityClassName); } $targetTable->addOption(OroOptions::KEY, $options); $associationName = ExtendHelper::buildAssociationName($this->extendExtension->getEntityClassByTableName($targetTableName), ActivityScope::ASSOCIATION_KIND); $this->extendExtension->addManyToManyRelation($schema, $activityTableName, $associationName, $targetTable, $targetTitleColumnNames, $targetDetailedColumnNames, $targetGridColumnNames, ['extend' => ['without_default' => true]]); }
protected function processRequest(Request $request) { /** @var NoteSoap $note */ $note = $request->request->get('note'); /** @var EntityIdSoap $association */ $association = $note['entityId']; if ($association && $association['id']) { /** @var ConfigProvider $noteProvider */ $noteProvider = $this->configManager->getProvider('note'); /** @var ConfigProvider $extendProvider */ $extendProvider = $this->configManager->getProvider('extend'); $fieldName = ExtendHelper::buildAssociationName($association['entity']); if ($noteProvider->hasConfig(Note::ENTITY_NAME, $fieldName) && $extendProvider->getConfig(Note::ENTITY_NAME, $fieldName)->is('state', ExtendScope::STATE_ACTIVE)) { $note[$fieldName] = $association['id']; unset($note['entityId']); $request->request->set('note', $note); } else { throw new \SoapFault('NOT_FOUND', sprintf('Notes do not enabled or schema not updated for given entity "%s".', $association['entity'])); } } else { throw new \SoapFault('NOT_FOUND', 'Associated entity OR it\'s instance Id not found.'); } return $request; }
/** * @param EntityManager $em * @param array $data * @param string $entityIdField * * @return QueryBuilder */ protected function createActivityQueryBuilder(EntityManager $em, array $data, $entityIdField) { $joinField = sprintf('%s.%s', $this->activityListAlias, ExtendHelper::buildAssociationName($data['entityClassName'], ActivityListEntityConfigDumperExtension::ASSOCIATION_KIND)); $activityListRepository = $em->getRepository('OroActivityListBundle:ActivityList'); $activityQb = $activityListRepository->createQueryBuilder($this->activityListAlias)->select('1')->setMaxResults(1); $availableActivityAssociations = $this->activityManager->getActivityAssociations($data['entityClassName']); if (!$availableActivityAssociations && !$activityListRepository->getRecordsCountForTargetClass($data['entityClassName'])) { $activityQb->andWhere('1 = 0'); return $activityQb; } $activityQb->join($joinField, $this->activityAlias)->andWhere(sprintf('%s.id = %s.%s', $this->activityAlias, $this->getEntityAlias(), $entityIdField)); $entityField = $this->getField(); $dateRangeField = strpos($entityField, '$') === 0 ? substr($entityField, 1) : null; if ($dateRangeField) { $data['dateRange'] = $data['filter']['data']; unset($data['filter']); } $this->activityListFilterHelper->addFiltersToQuery($activityQb, $data, $dateRangeField, $this->activityListAlias); if (isset($data['filter'])) { $activityDs = new OrmFilterDatasourceAdapter($activityQb); $expr = $activityDs->expr()->exists($this->createRelatedActivityDql($activityDs, $data)); $this->applyFilterToClause($activityDs, $expr); } return $activityQb; }