/**
* @param EmailCampaign $emailCampaign
* @param object $entity
* @return EmailCampaignStatistics
*/
public function getStatisticsRecord(EmailCampaign $emailCampaign, $entity)
{
$marketingList = $emailCampaign->getMarketingList();
$entityId = $this->doctrineHelper->getSingleEntityIdentifier($entity);
/**
* Cache was added because there is a case:
* - 2 email campaigns linked to one marketing list
* - statistic can created using batches (marketing list item connector will be used)
* and flush will be run once per N records creation
* in this case same Marketing list entity will be received twice for one marketing list
* and new MarketingListItem for same $marketingList and $entityId will be persisted twice.
*
* Marketing list name used as key for cache because Id can be empty and name is unique
*
*/
if (empty($this->marketingListItemCache[$marketingList->getName()][$entityId])) {
// Mark marketing list item as contacted
$this->marketingListItemCache[$marketingList->getName()][$entityId] = $this->marketingListItemConnector->getMarketingListItem($marketingList, $entityId);
}
/** @var MarketingListItem $marketingListItem */
$marketingListItem = $this->marketingListItemCache[$marketingList->getName()][$entityId];
$manager = $this->doctrineHelper->getEntityManager($this->entityName);
$statisticsRecord = null;
if ($marketingListItem->getId() !== null) {
$statisticsRecord = $manager->getRepository($this->entityName)->findOneBy(['emailCampaign' => $emailCampaign, 'marketingListItem' => $marketingListItem]);
}
if (!$statisticsRecord) {
$statisticsRecord = new EmailCampaignStatistics();
$statisticsRecord->setEmailCampaign($emailCampaign)->setMarketingListItem($marketingListItem)->setOwner($emailCampaign->getOwner())->setOrganization($emailCampaign->getOrganization());
$manager->persist($statisticsRecord);
}
return $statisticsRecord;
}
/**
* {@inheritdoc}
*/
public function batchUpdate(MassActionInterface $massAction, IterableResultInterface $results, array $data)
{
$this->entityName = $massAction->getOptions()->offsetGet('entityName');
$this->fieldName = empty($data['mass_edit_field']) ? null : $data['mass_edit_field'];
if (empty($this->fieldName)) {
throw new \RuntimeException("Field name was not specified with option 'mass_edit_field'");
}
$this->identifierName = $this->doctrineHelper->getSingleEntityIdentifierFieldName($this->entityName);
$value = $data[$this->fieldName];
$selectedIds = [];
$entitiesCount = 0;
$iteration = 0;
$this->entityManager = $this->doctrineHelper->getEntityManager($this->entityName);
$this->entityManager->beginTransaction();
try {
set_time_limit(0);
foreach ($results as $result) {
/** @var $result ResultRecordInterface */
$selectedIds[] = $result->getValue($this->identifierName);
$iteration++;
if ($iteration % $this->batchSize == 0) {
$entitiesCount += $this->finishBatch($selectedIds, $value);
}
}
if ($iteration % $this->batchSize > 0) {
$entitiesCount += $this->finishBatch($selectedIds, $value);
}
$this->entityManager->commit();
} catch (\Exception $e) {
$this->entityManager->rollback();
throw $e;
}
return $entitiesCount;
}
/**
* @param FormEvent $event
*/
public function postSetData(FormEvent $event)
{
$form = $event->getForm();
if ($form->getParent() || !$form->has($this->fieldName)) {
return;
}
$isEntityExists = false;
$entity = $event->getData();
if ($entity) {
if (!is_object($entity)) {
return;
}
$entityClass = ClassUtils::getClass($entity);
if (!$this->doctrineHelper->isManageableEntity($entityClass)) {
return;
}
$entityIdentifier = $this->doctrineHelper->getEntityManager($entityClass)->getClassMetadata($entityClass)->getIdentifierValues($entity);
$isEntityExists = !empty($entityIdentifier);
}
// if entity exists and assign is not granted - replace field with disabled text field,
// otherwise - set default owner value
if ($isEntityExists) {
$this->replaceOwnerField($form);
} else {
$this->setPredefinedOwner($form);
}
}
/**
* {@inheritdoc}
*/
public function merge(FieldData $fieldData)
{
$entityData = $fieldData->getEntityData();
$masterEntity = $entityData->getMasterEntity();
$sourceEntity = $fieldData->getSourceEntity();
if ($masterEntity->getId() !== $sourceEntity->getId()) {
$queryBuilder = $this->doctrineHelper->getEntityRepository('OroNoteBundle:Note')->getBaseAssociatedNotesQB(ClassUtils::getRealClass($masterEntity), $masterEntity->getId());
$notes = $queryBuilder->getQuery()->getResult();
if (!empty($notes)) {
$entityManager = $this->doctrineHelper->getEntityManager(current($notes));
foreach ($notes as $note) {
$entityManager->remove($note);
}
}
$queryBuilder = $this->doctrineHelper->getEntityRepository('OroNoteBundle:Note')->getBaseAssociatedNotesQB(ClassUtils::getRealClass($masterEntity), $sourceEntity->getId());
$notes = $queryBuilder->getQuery()->getResult();
if (!empty($notes)) {
foreach ($notes as $note) {
$note->setTarget($masterEntity);
}
}
$fieldMetadata = $fieldData->getMetadata();
$activityClass = $fieldMetadata->get('type');
$entityClass = ClassUtils::getRealClass($sourceEntity);
$queryBuilder = $this->doctrineHelper->getEntityRepository(ActivityList::ENTITY_NAME)->getActivityListQueryBuilderByActivityClass($entityClass, $sourceEntity->getId(), $activityClass);
$activityListItems = $queryBuilder->getQuery()->getResult();
$activityIds = ArrayUtils::arrayColumn($activityListItems, 'id');
$this->activityListManager->replaceActivityTargetWithPlainQuery($activityIds, $entityClass, $sourceEntity->getId(), $masterEntity->getId());
}
}
/**
* {@inheritdoc}
*/
public function guessColumnOptions($columnName, $entityName, $column)
{
$entityManager = $this->doctrineHelper->getEntityManager($entityName);
$metadata = $entityManager->getClassMetadata($entityName);
$result = [];
if ($metadata->hasField($columnName) && !$metadata->hasAssociation($columnName)) {
$result[Configuration::BASE_CONFIG_KEY] = [Configuration::CONFIG_ENABLE_KEY => true];
}
return $result;
}
/**
* Link new product with category from source product
*
* @param ProductDuplicateAfterEvent $event
*/
public function onDuplicateAfter(ProductDuplicateAfterEvent $event)
{
$product = $event->getProduct();
$sourceProduct = $event->getSourceProduct();
$category = $this->getCategoryRepository()->findOneByProduct($sourceProduct);
if ($category !== null) {
$category->addProduct($product);
$objectManager = $this->doctrineHelper->getEntityManager($this->categoryClass);
$objectManager->flush();
}
}
/**
* @param mixed $userId
* @return EmailOrigin[]
*/
public function getEmailOrigins($userId)
{
if (null === $this->emailOrigins) {
if ($userId) {
$user = $this->doctrineHelper->getEntityManager($this->userClass)->getRepository($this->userClass)->find($userId);
$this->emailOrigins = $user->getEmailOrigins();
} else {
$this->emailOrigins = [];
}
}
return $this->emailOrigins;
}
/**
* Check ACL for resource.
*
* @param mixed $context
* @return boolean
*/
protected function isConditionAllowed($context)
{
$attributes = $this->contextAccessor->getValue($context, $this->attributes);
$objectOrClass = $this->contextAccessor->getValue($context, $this->objectOrClass);
if (is_object($objectOrClass)) {
$unitOfWork = $this->doctrineHelper->getEntityManager($objectOrClass)->getUnitOfWork();
if (!$unitOfWork->isInIdentityMap($objectOrClass) || $unitOfWork->isScheduledForInsert($objectOrClass)) {
$objectOrClass = 'Entity:' . $this->doctrineHelper->getEntityClass($objectOrClass);
}
}
return $this->securityFacade->isGranted($attributes, $objectOrClass);
}
/**
* {@inheritdoc}
*/
protected function createSubordinateIterator($staticSegment)
{
$vars = $this->provider->provideExtendedMergeVars($staticSegment->getMarketingList());
$varNames = array_map(function ($each) {
return $each['name'];
}, $vars);
$qb = $this->doctrineHelper->getEntityManager($this->extendedMergeVarClassName)->getRepository($this->extendedMergeVarClassName)->createQueryBuilder('extendedMergeVar');
$qb->select(['extendedMergeVar.id', $staticSegment->getId() . ' static_segment_id', 'extendedMergeVar.name', $qb->expr()->literal(ExtendedMergeVar::STATE_REMOVE) . ' state']);
$qb->where($qb->expr()->andX($qb->expr()->eq('extendedMergeVar.staticSegment', ':staticSegment'), $qb->expr()->notIn('extendedMergeVar.name', ':vars'), $qb->expr()->neq('extendedMergeVar.state', ':state')))->setParameter('staticSegment', $staticSegment)->setParameter('vars', $varNames)->setParameter('state', ExtendedMergeVar::STATE_DROPPED);
$bufferedIterator = new BufferedQueryResultIterator($qb);
$bufferedIterator->setHydrationMode(AbstractQuery::HYDRATE_ARRAY)->setReverse(true);
return $bufferedIterator;
}
/**
* Copy product prices
*
* @param ProductDuplicateAfterEvent $event
*/
public function onDuplicateAfter(ProductDuplicateAfterEvent $event)
{
$product = $event->getProduct();
$sourceProduct = $event->getSourceProduct();
$productPrices = $this->getProductPriceRepository()->getPricesByProduct($sourceProduct);
$objectManager = $this->doctrineHelper->getEntityManager($this->productPriceClass);
foreach ($productPrices as $productPrice) {
$productPriceCopy = clone $productPrice;
$productPriceCopy->setProduct($product);
$objectManager->persist($productPriceCopy);
}
$objectManager->flush();
}
/**
* {@inheritdoc}
*/
public function write(array $items)
{
$entityManager = $this->doctrineHelper->getEntityManager($this->getClassName($items));
foreach ($items as $item) {
$entityManager->persist($item);
$this->detachFixer->fixEntityAssociationFields($item, 1);
}
$entityManager->flush();
$configuration = $this->getConfig();
if (empty($configuration[self::SKIP_CLEAR])) {
$entityManager->clear();
}
}
/**
* @param object $entity
* @param bool $allowCreate
*
* @return FieldsChanges
*/
protected function getOrCreateFieldsChanges($entity, $allowCreate = true)
{
$className = $this->doctrineHelper->getEntityClass($entity);
$identifier = $this->doctrineHelper->getSingleEntityIdentifier($entity);
$em = $this->doctrineHelper->getEntityManager($this->className);
$fieldChanges = $em->getRepository($this->className)->findOneBy(['entityClass' => $className, 'entityId' => $identifier]);
if ($fieldChanges || !$fieldChanges && !$allowCreate) {
return $fieldChanges;
}
$fieldChanges = $this->doctrineHelper->createEntityInstance($this->className)->setEntityClass($className)->setEntityId($identifier);
$em->persist($fieldChanges);
return $fieldChanges;
}
/**
* @param array $item
* @return QueryBuilder
*/
protected function createQueryBuilder(array $item)
{
$em = $this->doctrineHelper->getEntityManager($this->entityName);
$identifierFieldName = $this->doctrineHelper->getSingleEntityIdentifierFieldName($this->entityName);
$qb = $em->createQueryBuilder();
$qb->select('COUNT(e.' . $identifierFieldName . ') as itemsCount')->from($this->entityName, 'e');
if (array_key_exists($this->field, $item)) {
$qb->andWhere($qb->expr()->notIn('e.' . $this->field, ':items'))->setParameter('items', (array) $item[$this->field]);
}
// Workaround to limit by channel. Channel is not available in second step context.
if (array_key_exists('channel', $item)) {
$qb->andWhere($qb->expr()->eq('e.channel', ':channel'))->setParameter('channel', $item['channel']);
}
return $qb;
}
/**
* @param ProcessHandleEvent $event
*
* @throws \Exception
*/
public function onProcessHandleAfter(ProcessHandleEvent $event)
{
$entity = $event->getProcessData()->get('data');
if (!$entity instanceof MemberActivity) {
return;
}
$this->processCollectorListener->setEnabled(false);
try {
$this->doctrineHelper->getEntityManager($entity)->flush($entity);
} catch (\Exception $e) {
$this->processCollectorListener->setEnabled(true);
throw $e;
}
$this->processCollectorListener->setEnabled(true);
}
/**
* @param Channel $channel
* @param array $values
* @throws \Doctrine\DBAL\ConnectionException
* @throws \Exception
*/
protected function updateValues(Channel $channel, array $values)
{
if (count($values) === 0) {
return;
}
$entityFQCN = $channel->getCustomerIdentity();
$em = $this->doctrineHelper->getEntityManager($entityFQCN);
$idField = $this->doctrineHelper->getSingleEntityIdentifierFieldName($entityFQCN);
$connection = $em->getConnection();
$connection->beginTransaction();
try {
foreach ($values as $id => $value) {
$qb = $em->createQueryBuilder();
$qb->update($entityFQCN, 'e');
foreach ($value as $metricName => $metricValue) {
$qb->set('e.' . $metricName, ':' . $metricName);
$qb->setParameter($metricName, $metricValue);
}
$qb->where($qb->expr()->eq('e.' . $idField, ':id'));
$qb->setParameter('id', $id);
$qb->getQuery()->execute();
}
$connection->commit();
} catch (\Exception $e) {
$connection->rollBack();
throw $e;
}
}
/**
* @param FormInterface $form
* @param object $entity
* @return bool
* @throws \Exception
*/
protected function saveForm(FormInterface $form, $entity)
{
$event = new FormProcessEvent($form, $entity);
$this->eventDispatcher->dispatch(Events::BEFORE_FORM_DATA_SET, $event);
if ($event->isFormProcessInterrupted()) {
return false;
}
$form->setData($entity);
if (in_array($this->request->getMethod(), array('POST', 'PUT'))) {
$event = new FormProcessEvent($form, $entity);
$this->eventDispatcher->dispatch(Events::BEFORE_FORM_SUBMIT, $event);
if ($event->isFormProcessInterrupted()) {
return false;
}
$form->submit($this->request);
if ($form->isValid()) {
$manager = $this->doctrineHelper->getEntityManager($entity);
$manager->beginTransaction();
try {
$manager->persist($entity);
$this->eventDispatcher->dispatch(Events::BEFORE_FLUSH, new AfterFormProcessEvent($form, $entity));
$manager->flush();
$this->eventDispatcher->dispatch(Events::AFTER_FLUSH, new AfterFormProcessEvent($form, $entity));
$manager->commit();
} catch (\Exception $e) {
$manager->rollback();
throw $e;
}
return true;
}
}
return false;
}
/**
* {@inheritdoc}
*/
public function getData(ActivityList $activityListEntity)
{
/** @var Email $email */
$email = $headEmail = $this->doctrineRegistryLink->getService()->getRepository($activityListEntity->getRelatedActivityClass())->find($activityListEntity->getRelatedActivityId());
if ($email->isHead() && $email->getThread()) {
$headEmail = $this->emailThreadProvider->getHeadEmail($this->doctrineHelper->getEntityManager($activityListEntity->getRelatedActivityClass()), $email);
}
$data = ['ownerName' => $email->getFromName(), 'ownerLink' => null, 'entityId' => $email->getId(), 'headOwnerName' => $headEmail->getFromName(), 'headSubject' => $headEmail->getSubject(), 'headSentAt' => $headEmail->getSentAt()->format('c'), 'isHead' => $email->isHead() && $email->getThread(), 'treadId' => $email->getThread() ? $email->getThread()->getId() : null];
if ($email->getThread()) {
$emails = $email->getThread()->getEmails();
// if there are just two email - add replayedEmailId to use on client side
if (count($emails) === 2) {
$data['replayedEmailId'] = $emails[0]->getId();
}
}
if ($email->getFromEmailAddress()->getHasOwner()) {
$owner = $email->getFromEmailAddress()->getOwner();
$data['headOwnerName'] = $data['ownerName'] = $this->entityNameResolver->getName($owner);
$route = $this->configManager->getEntityMetadata(ClassUtils::getClass($owner))->getRoute('view');
$securityFacade = $this->securityFacadeLink->getService();
if (null !== $route && $securityFacade->isGranted('VIEW', $owner)) {
$id = $this->doctrineHelper->getSingleEntityIdentifier($owner);
try {
$data['ownerLink'] = $this->router->generate($route, ['id' => $id]);
} catch (RouteNotFoundException $e) {
// Do not set owner link if route is not found.
}
}
}
return $data;
}
public function testGetEntityManagerNotManageableEntity()
{
$class = 'ItemStubProxy';
$this->setExpectedException('Oro\\Bundle\\EntityBundle\\Exception\\NotManageableEntityException', sprintf('Entity class "%s" is not manageable', $class));
$this->registry->expects($this->once())->method('getManagerForClass')->with($class)->will($this->returnValue(null));
$this->doctrineHelper->getEntityManager($class);
}
/**
* @return EntityManager
*/
protected function getEntityManager()
{
if (null === $this->em) {
$this->em = $this->doctrineHelper->getEntityManager('OroEmailBundle:Email');
}
return $this->em;
}
public function testManagersCache()
{
$this->registry->expects($this->exactly(2))->method('getManagerForClass')->willReturn($this->onConsecutiveCalls($this->em, null));
$this->doctrineHelper->getEntityManager('\\stdClass');
$this->doctrineHelper->getEntityManager('\\stdClass');
$this->doctrineHelper->getEntityManager(new TestEntity(), false);
$this->doctrineHelper->getEntityManager(new TestEntity(), false);
}
/**
* @param object $entity
*/
public function resetIdentifier($entity)
{
$entityName = ClassUtils::getClass($entity);
/** @var EntityManager $entityManager */
$entityManager = $this->doctrineHelper->getEntityManager($entityName);
$identifierField = $this->getIdentifierFieldName($entityName);
$entityManager->getClassMetadata($entityName)->setIdentifierValues($entity, [$identifierField => null]);
}
/**
* @param EmailCampaign $emailCampaign
* @param object $entity
* @return EmailCampaignStatistics
*/
public function getStatisticsRecord(EmailCampaign $emailCampaign, $entity)
{
$marketingList = $emailCampaign->getMarketingList();
$entityId = $this->doctrineHelper->getSingleEntityIdentifier($entity);
// Mark marketing list item as contacted
$marketingListItem = $this->marketingListItemConnector->getMarketingListItem($marketingList, $entityId);
$manager = $this->doctrineHelper->getEntityManager($this->entityName);
$statisticsRecord = null;
if ($marketingListItem->getId() !== null) {
$statisticsRecord = $manager->getRepository($this->entityName)->findOneBy(['emailCampaign' => $emailCampaign, 'marketingListItem' => $marketingListItem]);
}
if (!$statisticsRecord) {
$statisticsRecord = new EmailCampaignStatistics();
$statisticsRecord->setEmailCampaign($emailCampaign)->setMarketingListItem($marketingListItem)->setOwner($emailCampaign->getOwner())->setOrganization($emailCampaign->getOrganization());
$manager->persist($statisticsRecord);
}
return $statisticsRecord;
}
/**
* @param FormInterface $form
* @param array $categories
*/
protected function addRFMTypes(FormInterface $form, array $categories)
{
foreach (RFMMetricCategory::$types as $type) {
$typeCategories = array_filter($categories, function (RFMMetricCategory $category) use($type) {
return $category->getCategoryType() === $type;
});
$collection = new PersistentCollection($this->doctrineHelper->getEntityManager($this->rfmCategoryClass), $this->doctrineHelper->getEntityMetadata($this->rfmCategoryClass), new ArrayCollection($typeCategories));
$collection->takeSnapshot();
$constraint = new CategoriesConstraint();
$constraint->setType($type);
$form->add($type, RFMCategorySettingsType::NAME, [RFMCategorySettingsType::TYPE_OPTION => $type, 'label' => sprintf('orocrm.analytics.form.%s.label', $type), 'tooltip' => sprintf('orocrm.analytics.%s.tooltip', $type), 'mapped' => false, 'required' => false, 'error_bubbling' => false, 'is_increasing' => $type === RFMMetricCategory::TYPE_RECENCY, 'constraints' => [$constraint], 'data' => $collection]);
}
}
/**
* @param string $entity
* @param string $keyField
* @param string $labelField
*
* @return array
*/
protected function getChoices($entity, $keyField, $labelField)
{
$entityManager = $this->doctrineHelper->getEntityManager($entity);
$queryBuilder = $entityManager->getRepository($entity)->createQueryBuilder('e');
//select only id and label fields
$queryBuilder->select("e.{$keyField}, e.{$labelField}");
$result = $this->aclHelper->apply($queryBuilder)->getResult();
$choices = [];
foreach ($result as $item) {
$choices[$item[$keyField]] = $item[$labelField];
}
return $choices;
}
/**
* @param FormInterface $form
* @param object $entity
* @return bool
*/
protected function saveForm(FormInterface $form, $entity)
{
$form->setData($entity);
if (in_array($this->request->getMethod(), array('POST', 'PUT'))) {
$form->submit($this->request);
if ($form->isValid()) {
$manager = $this->doctrineHelper->getEntityManager($entity);
$manager->persist($entity);
$manager->flush();
return true;
}
}
return false;
}
/**
* {@inheritdoc}
*/
public function getData(ActivityList $activityListEntity)
{
/** @var Email $email */
$email = $headEmail = $this->doctrineRegistryLink->getService()->getRepository($activityListEntity->getRelatedActivityClass())->find($activityListEntity->getRelatedActivityId());
if ($email->isHead() && $email->getThread()) {
$headEmail = $this->emailThreadProvider->getHeadEmail($this->doctrineHelper->getEntityManager($activityListEntity->getRelatedActivityClass()), $email);
}
$data = ['ownerName' => $email->getFromName(), 'ownerLink' => null, 'entityId' => $email->getId(), 'headOwnerName' => $headEmail->getFromName(), 'headSubject' => $headEmail->getSubject(), 'headSentAt' => $headEmail->getSentAt()->format('c'), 'isHead' => $email->isHead() && $email->getThread(), 'treadId' => $email->getThread() ? $email->getThread()->getId() : null];
$data = $this->setReplaedEmailId($email, $data);
if ($email->getFromEmailAddress()->getHasOwner()) {
$owner = $email->getFromEmailAddress()->getOwner();
$data['headOwnerName'] = $data['ownerName'] = $this->entityNameResolver->getName($owner);
$data = $this->setOwnerLink($owner, $data);
}
return $data;
}
/**
* @param Product $product
* @param Product $productCopy
*/
protected function cloneChildObjects(Product $product, Product $productCopy)
{
foreach ($product->getUnitPrecisions() as $unitPrecision) {
$productCopy->addUnitPrecision(clone $unitPrecision);
}
if ($imageFile = $product->getImage()) {
$imageFileCopy = $this->attachmentManager->copyAttachmentFile($imageFile);
$productCopy->setImage($imageFileCopy);
}
$attachments = $this->attachmentProvider->getEntityAttachments($product);
foreach ($attachments as $attachment) {
$attachmentCopy = clone $attachment;
$attachmentFileCopy = $this->attachmentManager->copyAttachmentFile($attachment->getFile());
$attachmentCopy->setFile($attachmentFileCopy);
$attachmentCopy->setTarget($productCopy);
$this->doctrineHelper->getEntityManager($attachmentCopy)->persist($attachmentCopy);
}
}
/**
* Returns a query builder that could be used for fetching the list of entities
* associated with $associationOwnerClass entities found by $filters and $joins
*
* @param string $associationTargetClass The FQCN of the entity that is the owning side of the association
* @param mixed|null $filters Criteria is used to filter entities which are association owners
* e.g. ['age' => 20, ...] or \Doctrine\Common\Collections\Criteria
* @param array|null $joins Additional associations required to filter owning side entities
* @param array $associationOwners The list of fields responsible to store associations between
* the given target and association owners
* Array format: [owner_entity_class => field_name]
* @param int $limit The maximum number of items per page
* @param int $page The page number
* @param string|null $orderBy The ordering expression for the result
*
* @return SqlQueryBuilder
*/
public function getMultiAssociationOwnersQueryBuilder($associationTargetClass, $filters, $joins, $associationOwners, $limit = null, $page = null, $orderBy = null)
{
$em = $this->doctrineHelper->getEntityManager($associationTargetClass);
$criteria = $this->doctrineHelper->normalizeCriteria($filters);
$selectStmt = null;
$subQueries = [];
$targetIdFieldName = $this->doctrineHelper->getSingleEntityIdentifierFieldName($associationTargetClass);
foreach ($associationOwners as $ownerClass => $fieldName) {
// dispatch oro_api.request.get_list.before event
$event = new GetListBefore($this->cloneCriteria($criteria), $associationTargetClass);
$this->eventDispatcher->dispatch(GetListBefore::NAME, $event);
$subCriteria = $event->getCriteria();
$nameExpr = $this->entityNameResolver->getNameDQL($ownerClass, 'e');
$subQb = $em->getRepository($ownerClass)->createQueryBuilder('e')->select(sprintf('target.%s AS id, e.id AS entityId, \'%s\' AS entityClass, ' . ($nameExpr ?: '\'\'') . ' AS entityTitle', $targetIdFieldName, str_replace('\'', '\'\'', $ownerClass)))->innerJoin('e.' . $fieldName, 'target');
$this->doctrineHelper->applyJoins($subQb, $joins);
// fix of doctrine error with Same Field, Multiple Values, Criteria and QueryBuilder
// http://www.doctrine-project.org/jira/browse/DDC-2798
// TODO revert changes when doctrine version >= 2.5 in scope of BAP-5577
QueryBuilderHelper::addCriteria($subQb, $subCriteria);
// $subQb->addCriteria($criteria);
$subQuery = $subQb->getQuery();
$subQueries[] = QueryUtils::getExecutableSql($subQuery);
if (empty($selectStmt)) {
$mapping = QueryUtils::parseQuery($subQuery)->getResultSetMapping();
$selectStmt = sprintf('entity.%s AS id, entity.%s AS entity, entity.%s AS title', QueryUtils::getColumnNameByAlias($mapping, 'entityId'), QueryUtils::getColumnNameByAlias($mapping, 'entityClass'), QueryUtils::getColumnNameByAlias($mapping, 'entityTitle'));
}
}
$rsm = new ResultSetMapping();
$rsm->addScalarResult('id', 'id', Type::INTEGER)->addScalarResult('entity', 'entity')->addScalarResult('title', 'title');
$qb = new SqlQueryBuilder($em, $rsm);
$qb->select($selectStmt)->from('(' . implode(' UNION ALL ', $subQueries) . ')', 'entity');
if (null !== $limit) {
$qb->setMaxResults($limit);
if (null !== $page) {
$qb->setFirstResult($this->doctrineHelper->getPageOffset($page, $limit));
}
}
if ($orderBy) {
$qb->orderBy($orderBy);
}
return $qb;
}
/**
* This method should be used for fast changing data in 'relation' tables, because
* it uses Plain SQL for updating data in tables.
* Currently there is no another way for updating big amount of data: with Doctrine way
* it takes a lot of time(because of big amount of operations with objects, event listeners etc.);
* with DQL currently it impossible to build query, because DQL works only with entities, but
* 'relation' tables are not entities. For example: there is 'relation'
* table 'oro_rel_c3990ba6b28b6f38c460bc' and it has activitylist_id and account_id columns,
* in fact to solve initial issue with big amount of data we need update only account_id column
* with new values.
*
* @param array $activityIds
* @param string $targetClass
* @param integer $oldTargetId
* @param integer $newTargetId
* @param null|string $activityClass
*
* @return $this
*
* @throws \Doctrine\DBAL\DBALException
* @throws \Doctrine\ORM\Mapping\MappingException
*/
public function replaceActivityTargetWithPlainQuery(array $activityIds, $targetClass, $oldTargetId, $newTargetId, $activityClass = null)
{
if (is_null($activityClass)) {
$associationName = $this->getActivityListAssociationName($targetClass);
$entityClass = ActivityList::ENTITY_NAME;
} else {
$associationName = $this->getActivityAssociationName($targetClass);
$entityClass = $activityClass;
}
$entityMetadata = $this->doctrineHelper->getEntityMetadata($entityClass);
if (!empty($activityIds) && $entityMetadata->hasAssociation($associationName)) {
$association = $entityMetadata->getAssociationMapping($associationName);
$tableName = $association['joinTable']['name'];
$activityField = current(array_keys($association['relationToSourceKeyColumns']));
$targetField = current(array_keys($association['relationToTargetKeyColumns']));
$where = "WHERE {$targetField} = :sourceEntityId AND {$activityField} IN(" . implode(',', $activityIds) . ")";
$dbConnection = $this->doctrineHelper->getEntityManager(ActivityList::ENTITY_NAME)->getConnection()->prepare("UPDATE {$tableName} SET {$targetField} = :masterEntityId {$where}");
$dbConnection->bindValue('masterEntityId', $newTargetId);
$dbConnection->bindValue('sourceEntityId', $oldTargetId);
$dbConnection->execute();
}
return $this;
}
/**
* Returns a query builder that could be used for fetching the list of owner side entities
* the specified $associationTargetClass associated with.
* The $filters and $joins could be used to filter entities
*
* The resulting query would be something like this:
* <code>
* SELECT entity.entityId AS id, entity.entityClass AS entity, entity.entityTitle AS title FROM (
* SELECT [DISTINCT]
* target.id AS id,
* e.id AS entityId,
* {first_owner_entity_class} AS entityClass,
* {first_owner_title} AS entityTitle
* FROM {first_owner_entity_class} AS e
* INNER JOIN e.{target_field_name_for_first_owner} AS target
* {joins}
* WHERE {filters}
* UNION ALL
* SELECT [DISTINCT]
* target.id AS id,
* e.id AS entityId,
* {second_owner_entity_class} AS entityClass,
* {second_owner_title} AS entityTitle
* FROM {second_owner_entity_class} AS e
* INNER JOIN e.{target_field_name_for_second_owner} AS target
* {joins}
* WHERE {filters}
* UNION ALL
* ... select statements for other owners
* ) entity
* ORDER BY {orderBy}
* LIMIT {limit} OFFSET {(page - 1) * limit}
* </code>
*
* @param string $associationTargetClass The FQCN of the entity that is the target side of the association
* @param mixed|null $filters Criteria is used to filter entities which are association owners
* e.g. ['age' => 20, ...] or \Doctrine\Common\Collections\Criteria
* @param array|null $joins Additional associations required to filter owning side entities
* @param array $associationOwners The list of fields responsible to store associations between
* the given target and association owners
* Array format: [owner_entity_class => field_name]
* @param int|null $limit The maximum number of items per page
* @param int|null $page The page number
* @param string|null $orderBy The ordering expression for the result
* @param callable|null $callback A callback function which can be used to modify child queries
* function (QueryBuilder $qb, $ownerEntityClass)
*
* @return SqlQueryBuilder
*/
public function getMultiAssociationOwnersQueryBuilder($associationTargetClass, $filters, $joins, $associationOwners, $limit = null, $page = null, $orderBy = null, $callback = null)
{
$em = $this->doctrineHelper->getEntityManager($associationTargetClass);
$criteria = QueryUtils::normalizeCriteria($filters);
$selectStmt = null;
$subQueries = [];
$targetIdFieldName = $this->doctrineHelper->getSingleEntityIdentifierFieldName($associationTargetClass);
foreach ($associationOwners as $ownerClass => $fieldName) {
$nameExpr = $this->entityNameResolver->getNameDQL($ownerClass, 'e');
$subQb = $em->getRepository($ownerClass)->createQueryBuilder('e')->select(sprintf('target.%s AS id, e.id AS entityId, \'%s\' AS entityClass, ' . ($nameExpr ?: '\'\'') . ' AS entityTitle', $targetIdFieldName, str_replace('\'', '\'\'', $ownerClass)))->innerJoin('e.' . $fieldName, 'target');
QueryUtils::applyJoins($subQb, $joins);
$subQb->addCriteria($criteria);
if (null !== $callback && is_callable($callback)) {
call_user_func($callback, $subQb, $ownerClass);
}
$subQuery = $this->getAclHelper()->apply($subQb);
$subQueries[] = QueryUtils::getExecutableSql($subQuery);
if (empty($selectStmt)) {
$mapping = QueryUtils::parseQuery($subQuery)->getResultSetMapping();
$selectStmt = sprintf('entity.%s AS id, entity.%s AS entity, entity.%s AS title', QueryUtils::getColumnNameByAlias($mapping, 'entityId'), QueryUtils::getColumnNameByAlias($mapping, 'entityClass'), QueryUtils::getColumnNameByAlias($mapping, 'entityTitle'));
}
}
$rsm = new ResultSetMapping();
$rsm->addScalarResult('id', 'id', Type::INTEGER)->addScalarResult('entity', 'entity')->addScalarResult('title', 'title');
$qb = new SqlQueryBuilder($em, $rsm);
$qb->select($selectStmt)->from('(' . implode(' UNION ALL ', $subQueries) . ')', 'entity');
if (null !== $limit) {
$qb->setMaxResults($limit);
if (null !== $page) {
$qb->setFirstResult(QueryUtils::getPageOffset($page, $limit));
}
}
if ($orderBy) {
$qb->orderBy($orderBy);
}
return $qb;
}
