/** * {@inheritdoc} */ protected function getChoices($entityName, $withRelations, $withVirtualFields) { $choiceFields = []; $choiceRelations = []; $idFieldNames = $this->doctrineHelper->getEntityIdentifierFieldNames($entityName); foreach ($this->getEntityFields($entityName, $withRelations, $withVirtualFields) as $fieldName => $field) { $formConfig = $this->formConfigProvider->getConfig($entityName, $fieldName); if ($formConfig->is('is_enabled', false) || in_array($fieldName, $idFieldNames)) { // field is not enabled for displaying in forms // or field is entity identifier continue; } if (!isset($field['relation_type'])) { $choiceFields[$fieldName] = $field['label']; } elseif (!in_array($field['relation_type'], RelationType::$toManyRelations)) { // enable only mass update for *-to-one relations $choiceRelations[$fieldName] = $field['label']; } } if (empty($choiceRelations)) { return $choiceFields; } $choices = []; if (!empty($choiceFields)) { $choices[$this->translator->trans('oro.entity.form.entity_fields')] = $choiceFields; } $choices[$this->translator->trans('oro.entity.form.entity_related')] = $choiceRelations; return $choices; }
/** * {@inheritdoc} */ public function getCalendarEvents($organizationId, $userId, $calendarId, $start, $end, $connections, $extraFields = []) { if (!$this->calendarConfig->isSystemCalendarEnabled() || !$this->securityFacade->isGranted('oro_system_calendar_view')) { return []; } //@TODO: temporary return all system calendars until BAP-6566 implemented ///** @var CalendarEventRepository $repo */ //$repo = $this->doctrineHelper->getEntityRepository('OroCalendarBundle:CalendarEvent'); //$qb = $repo->getSystemEventListByTimeIntervalQueryBuilder( // $calendarId, // $start, // $end, // [] //); /** @var CalendarEventRepository $repo */ $repo = $this->doctrineHelper->getEntityRepository('OroCalendarBundle:CalendarEvent'); $qb = $repo->getSystemEventListByTimeIntervalQueryBuilder($start, $end, [], $extraFields)->andWhere('c.organization = :organizationId')->setParameter('organizationId', $organizationId); $invisibleIds = []; foreach ($connections as $id => $visible) { if (!$visible) { $invisibleIds[] = $id; } } if (!empty($invisibleIds)) { $qb->andWhere('c.id NOT IN (:invisibleIds)')->setParameter('invisibleIds', $invisibleIds); } return $this->calendarEventNormalizer->getCalendarEvents($calendarId, $qb->getQuery()); }
/** * @param BuildAfter $event */ public function onBuildAfter(BuildAfter $event) { /** @var OrmDatasource $dataSource */ $datagrid = $event->getDatagrid(); $config = $datagrid->getConfig(); $configParameters = $config->toArray(); if (!array_key_exists('extended_entity_name', $configParameters) || !$configParameters['extended_entity_name']) { return; } $targetClass = $configParameters['extended_entity_name']; $parameters = $datagrid->getParameters(); $dataSource = $datagrid->getDatasource(); $queryBuilder = $dataSource->getQueryBuilder(); $alias = current($queryBuilder->getDQLPart('from'))->getAlias(); if ($dataSource instanceof OrmDatasource && $parameters->has('activityId') && $parameters->has('activityClass')) { $id = $parameters->get('activityId'); $class = $parameters->get('activityClass'); $entityClass = $this->entityClassNameHelper->resolveEntityClass($class, true); $entity = $this->doctrineHelper->getEntity($entityClass, $id); if ($entity && $entity instanceof ActivityInterface) { $targetsArray = $entity->getActivityTargets($targetClass); $targetIds = []; foreach ($targetsArray as $target) { $targetIds[] = $target->getId(); } if ($targetIds) { $queryBuilder->andWhere($queryBuilder->expr()->notIn(sprintf('%s.id', $alias), $targetIds)); } } } }
/** * Collect activities changes * * @param OnFlushEventArgs $args */ public function onFlush(OnFlushEventArgs $args) { $entitiesToDelete = $args->getEntityManager()->getUnitOfWork()->getScheduledEntityDeletions(); $entitiesToUpdate = $args->getEntityManager()->getUnitOfWork()->getScheduledEntityUpdates(); if (!empty($entitiesToDelete) || !empty($entitiesToUpdate)) { foreach ($entitiesToDelete as $entity) { $class = $this->doctrineHelper->getEntityClass($entity); $id = $this->doctrineHelper->getSingleEntityIdentifier($entity); $key = $class . '_' . $id; if ($this->activityContactProvider->isSupportedEntity($class) && !isset($this->deletedEntities[$key])) { $targets = $entity->getActivityTargetEntities(); $targetsInfo = []; foreach ($targets as $target) { $targetsInfo[] = ['class' => $this->doctrineHelper->getEntityClass($target), 'id' => $this->doctrineHelper->getSingleEntityIdentifier($target), 'direction' => $this->activityContactProvider->getActivityDirection($entity, $target)]; } $this->deletedEntities[$key] = ['class' => $class, 'id' => $id, 'contactDate' => $this->activityContactProvider->getActivityDate($entity), 'targets' => $targetsInfo]; } } foreach ($entitiesToUpdate as $entity) { $class = $this->doctrineHelper->getEntityClass($entity); $id = $this->doctrineHelper->getSingleEntityIdentifier($entity); $key = $class . '_' . $id; if ($this->activityContactProvider->isSupportedEntity($class) && !isset($this->updatedEntities[$key])) { $changes = $args->getEntityManager()->getUnitOfWork()->getEntityChangeSet($entity); $isDirectionChanged = $this->activityContactProvider->getActivityDirectionProvider($entity)->isDirectionChanged($changes); $targets = $entity->getActivityTargetEntities(); $targetsInfo = []; foreach ($targets as $target) { $targetsInfo[] = ['class' => $this->doctrineHelper->getEntityClass($target), 'id' => $this->doctrineHelper->getSingleEntityIdentifier($target), 'direction' => $this->activityContactProvider->getActivityDirection($entity, $target), 'is_direction_changed' => $isDirectionChanged]; } $this->updatedEntities[$key] = ['class' => $class, 'id' => $id, 'contactDate' => $this->activityContactProvider->getActivityDate($entity), 'targets' => $targetsInfo]; } } } }
/** * Delegated method * * @param object $entity * @return bool */ public function isAttachmentAssociationEnabled($entity) { if (!is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || $this->doctrineHelper->isNewEntity($entity)) { return false; } return $this->config->isAttachmentAssociationEnabled($entity); }
/** * @param StaticSegment $staticSegment * * {@inheritdoc} */ protected function createSubordinateIterator($staticSegment) { $this->assertRequiredDependencies(); if (!$staticSegment->getExtendedMergeVars()) { return new \EmptyIterator(); } $qb = $this->getIteratorQueryBuilder($staticSegment); $marketingList = $staticSegment->getMarketingList(); $memberIdentifier = MarketingListQueryBuilderAdapter::MEMBER_ALIAS . '.id'; $fieldExpr = $this->fieldHelper->getFieldExpr($marketingList->getEntity(), $qb, $this->doctrineHelper->getSingleEntityIdentifierFieldName($marketingList->getEntity())); $qb->addSelect($fieldExpr . ' AS entity_id'); $qb->addSelect($memberIdentifier . ' AS member_id'); $qb->andWhere($qb->expr()->andX($qb->expr()->isNotNull($memberIdentifier))); $bufferedIterator = new BufferedQueryResultIterator($qb); $bufferedIterator->setHydrationMode(AbstractQuery::HYDRATE_ARRAY)->setReverse(true); $uniqueMembers =& $this->uniqueMembers; return new \CallbackFilterIterator($bufferedIterator, function (&$current) use($staticSegment, &$uniqueMembers) { if (is_array($current)) { if (!empty($current['member_id']) && in_array($current['member_id'], $uniqueMembers, true)) { return false; } $current['subscribersList_id'] = $staticSegment->getSubscribersList()->getId(); $current['static_segment_id'] = $staticSegment->getId(); $uniqueMembers[] = $current['member_id']; unset($current['id']); } return true; }); }
/** * @param object $entity * @return object|null */ public function discoverSimilar($entity) { if (!$this->configuration) { return null; } $idName = $this->doctrineHelper->getSingleEntityIdentifierFieldName($this->discoveryEntityClass); $idFieldName = self::ROOT_ALIAS . '.' . $idName; /** @var EntityRepository $repository */ $repository = $this->doctrineHelper->getEntityRepository($this->discoveryEntityClass); $qb = $repository->createQueryBuilder(self::ROOT_ALIAS)->select(self::ROOT_ALIAS); // Apply search strategies $this->applyStrategies($qb, $entity); // Apply matcher strategy if ($this->configuration[Configuration::DISCOVERY_OPTIONS_KEY][Configuration::DISCOVERY_MATCH_KEY] === Configuration::DISCOVERY_MATCH_LATEST) { $qb->orderBy($idFieldName, Criteria::DESC); } // Skip current entity $id = $this->doctrineHelper->getSingleEntityIdentifier($entity); if (!empty($id)) { $idParameter = ':' . $idName; $qb->andWhere($qb->expr()->neq($idFieldName, $idParameter))->setParameter($idParameter, $id); } // Add organization limits $organizationField = $this->ownershipMetadata->getMetadata(ClassUtils::getClass($entity))->getOrganizationFieldName(); if ($organizationField) { $propertyAccessor = PropertyAccess::createPropertyAccessor(); $organization = $propertyAccessor->getValue($entity, $organizationField); $qb->andWhere(sprintf('%s.%s = :organization', self::ROOT_ALIAS, $organizationField))->setParameter('organization', $organization); } // Get only 1 match $qb->setMaxResults(1); return $qb->getQuery()->getOneOrNullResult(); }
public function testMerge() { $account1 = new User(); $account2 = new User(); $this->setId($account1, 1); $this->setId($account2, 2); $entityMetadata = new EntityMetadata(['type' => ClassUtils::getRealClass($account1)]); $entityData = new EntityData($entityMetadata, [$account1, $account2]); $entityData->setMasterEntity($account1); $fieldData = new FieldData($entityData, new FieldMetadata()); $fieldData->setMode(MergeModes::NOTES_REPLACE); $fieldData->setSourceEntity($account2); $queryBuilder = $this->getMockBuilder('Doctrine\\ORM\\QueryBuilder')->disableOriginalConstructor()->setMethods(['getQuery', 'getResult'])->getMock(); $queryBuilder->expects($this->any())->method('getQuery')->will($this->returnSelf()); $queryBuilder->expects($this->any())->method('getResult')->will($this->returnValue([new ExtendNote()])); $repository = $this->getMockBuilder('Oro\\Bundle\\ActivityListBundle\\Entity\\Repository\\ActivityListRepository')->disableOriginalConstructor()->setMethods(['getBaseAssociatedNotesQB', 'getActivityListQueryBuilderByActivityClass'])->getMock(); $repository->expects($this->any())->method('getBaseAssociatedNotesQB')->willReturn($queryBuilder); $activityQueryBuilder = $this->getMockBuilder('Doctrine\\ORM\\QueryBuilder')->disableOriginalConstructor()->setMethods(['getQuery', 'getResult'])->getMock(); $activityQueryBuilder->expects($this->any())->method('getQuery')->will($this->returnSelf()); $activityQueryBuilder->expects($this->any())->method('getResult')->will($this->returnValue([['id' => 1, 'relatedActivityId' => 11], ['id' => 3, 'relatedActivityId' => 2]])); $repository->expects($this->any())->method('getActivityListQueryBuilderByActivityClass')->willReturn($activityQueryBuilder); $entityManager = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->setMethods(['remove'])->getMock(); $this->doctrineHelper->expects($this->any())->method('getEntityRepository')->willReturn($repository); $this->doctrineHelper->expects($this->any())->method('getEntityManager')->willReturn($entityManager); $this->activityListManager->expects($this->once())->method('replaceActivityTargetWithPlainQuery'); $this->strategy->merge($fieldData); }
/** * @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 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} */ protected function applyAdditionalData(&$items, $calendarId) { $parentEventIds = $this->getParentEventIds($items); if (!empty($parentEventIds)) { /** @var CalendarEventRepository $repo */ $repo = $this->doctrineHelper->getEntityRepository('OroCalendarBundle:CalendarEvent'); $invitees = $repo->getInvitedUsersByParentsQueryBuilder($parentEventIds)->getQuery()->getArrayResult(); $groupedInvitees = []; foreach ($invitees as $invitee) { $groupedInvitees[$invitee['parentEventId']][] = $invitee; } foreach ($items as &$item) { $item['invitedUsers'] = []; if (isset($groupedInvitees[$item['id']])) { foreach ($groupedInvitees[$item['id']] as $invitee) { $item['invitedUsers'][] = $invitee['userId']; } } } } else { foreach ($items as &$item) { $item['invitedUsers'] = []; } } }
/** * 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; } return $this->commentAssociationHelper->isCommentAssociationEnabled(ClassUtils::getClass($entity)); }
/** * {@inheritdoc} */ public function getDirection($activity, $target) { //check if target is entity created from admin part if (!$target instanceof EmailHolderInterface) { $metadata = $this->doctrineHelper->getEntityMetadata($target); $columns = $metadata->getColumnNames(); $className = get_class($target); foreach ($columns as $column) { //check only columns with 'contact_information' if ($this->isEmailType($className, $column)) { $getMethodName = "get" . Inflector::classify($column); /** @var $activity Email */ if ($activity->getFromEmailAddress()->getEmail() === $target->{$getMethodName}()) { return DirectionProviderInterface::DIRECTION_OUTGOING; } else { foreach ($activity->getTo() as $recipient) { if ($recipient->getEmailAddress()->getEmail() === $target->{$getMethodName}()) { return DirectionProviderInterface::DIRECTION_INCOMING; } } } } } return DirectionProviderInterface::DIRECTION_UNKNOWN; } /** @var $activity Email */ /** @var $target EmailHolderInterface */ if ($activity->getFromEmailAddress()->getEmail() === $target->getEmail()) { return DirectionProviderInterface::DIRECTION_OUTGOING; } return DirectionProviderInterface::DIRECTION_INCOMING; }
/** * @dataProvider skuDataProvider * @param string[] $existingSku * @param array $testCases */ public function testIncrementSku(array $existingSku, array $testCases) { $this->doctrineHelper->expects($this->any())->method('getEntityRepository')->with(self::PRODUCT_CLASS)->willReturn($this->getProductRepositoryMock($existingSku)); foreach ($testCases as $expected => $sku) { $this->assertEquals($expected, $this->service->increment($sku)); } }
/** * Checks if the entity can has notes * * @param object $entity * @return bool */ public function isNoteAssociationEnabled($entity) { if (!is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || $this->doctrineHelper->isNewEntity($entity)) { return false; } return $this->noteAssociationHelper->isNoteAssociationEnabled(ClassUtils::getClass($entity)); }
/** * {@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 bool $withRelations * * @dataProvider testDataProvider */ public function testBuildFormRegularGuesser($withRelations) { $entityName = 'Test\\Entity'; $this->doctrineHelperMock->expects($this->once())->method('getEntityIdentifierFieldNames')->with($entityName)->willReturn(['id']); $fields = [['name' => 'oneField', 'type' => 'string', 'label' => 'One field'], ['name' => 'anotherField', 'type' => 'string', 'label' => 'Another field']]; if ($withRelations) { $fields[] = ['name' => 'relField', 'relation_type' => 'ref-one', 'label' => 'Many to One field']; } $this->entityFieldMock->expects($this->once())->method('getFields')->willReturn($fields); $this->formConfigMock->expects($this->at(0))->method('getConfig')->with($entityName, 'oneField')->willReturn(new Config(new FieldConfigId('form', $entityName, 'someField'), ['is_enabled' => false])); $this->formConfigMock->expects($this->at(1))->method('getConfig')->with($entityName, 'anotherField')->willReturn(new Config(new FieldConfigId('form', $entityName, 'anotherField'), ['is_enabled' => true])); if ($withRelations) { $this->formConfigMock->expects($this->at(2))->method('getConfig')->with($entityName, 'relField')->willReturn(new Config(new FieldConfigId('form', $entityName, 'relField'), ['is_enabled' => true])); $this->translatorMock->expects($this->at(0))->method('trans')->with('oro.entity.form.entity_fields')->willReturn('Fields'); $this->translatorMock->expects($this->at(1))->method('trans')->with('oro.entity.form.entity_related')->willReturn('Relations'); } $form = $this->factory->create($this->type, null, ['entity' => $entityName, 'with_relations' => $withRelations]); $view = $form->createView(); $this->assertEquals('update_field_choice', $view->vars['full_name'], 'Failed asserting that field name is correct'); $this->assertNotEmpty($view->vars['configs']['component']); $this->assertEquals('entity-field-choice', $view->vars['configs']['component']); $this->assertEquals('update_field_choice', $form->getConfig()->getType()->getName(), 'Failed asserting that correct underlying type was used'); if ($withRelations) { $this->assertCount(2, $view->vars['choices'], 'Failed asserting that choices are grouped'); } else { $this->assertCount(1, $view->vars['choices'], 'Failed asserting that choices exists'); /** @var ChoiceView $choice */ $choice = reset($view->vars['choices']); $this->assertEquals('Another field', $choice->label); } }
/** * {@inheritdoc} */ public function buildForm(FormBuilderInterface $builder, array $options) { if (empty($options['data_class'])) { return; } $className = $options['data_class']; if (!$this->doctrineHelper->isManageableEntity($className)) { return; } if (!$this->entityConfigProvider->hasConfig($className)) { return; } $uniqueKeys = $this->entityConfigProvider->getConfig($className)->get('unique_key'); if (empty($uniqueKeys)) { return; } /* @var \Symfony\Component\Validator\Mapping\ClassMetadata $validatorMetadata */ $validatorMetadata = $this->validator->getMetadataFor($className); foreach ($uniqueKeys['keys'] as $uniqueKey) { $fields = $uniqueKey['key']; $labels = array_map(function ($fieldName) use($className) { $label = $this->entityConfigProvider->getConfig($className, $fieldName)->get('label'); return $this->translator->trans($label); }, $fields); $constraint = new UniqueEntity(['fields' => $fields, 'errorPath' => '', 'message' => $this->translator->transChoice('oro.entity.validation.unique_field', sizeof($fields), ['%field%' => implode(', ', $labels)])]); $validatorMetadata->addConstraint($constraint); } }
/** * @param string $message * @param ProcessTrigger $trigger * @param ProcessData $data */ public function debug($message, ProcessTrigger $trigger, ProcessData $data) { if ($this->logger) { $context = array('definition' => $trigger->getDefinition()->getName(), 'event' => $trigger->getEvent(), 'entityId' => $this->doctrineHelper->getSingleEntityIdentifier($data['data'], false)); $this->logger->debug($message, $context); } }
/** * Returns the context for the given activity class and id * * @param string $class The FQCN of the activity entity * @param $id * * @return array */ public function getActivityContext($class, $id) { $currentUser = $this->securityTokenStorage->getToken()->getUser(); $userClass = ClassUtils::getClass($currentUser); $entity = $this->doctrineHelper->getEntity($class, $id); $result = []; if (!$entity || !$entity instanceof ActivityInterface) { return $result; } $targets = $entity->getActivityTargetEntities(); $entityProvider = $this->configManager->getProvider('entity'); foreach ($targets as $target) { $targetClass = ClassUtils::getClass($target); $targetId = $target->getId(); if ($userClass === $targetClass && $currentUser->getId() === $targetId) { continue; } $item = []; $config = $entityProvider->getConfig($targetClass); $safeClassName = $this->entityClassNameHelper->getUrlSafeClassName($targetClass); $item = $this->prepareItemTitle($item, $targetClass, $target, $targetId); $item['activityClassAlias'] = $this->entityAliasResolver->getPluralAlias($class); $item['entityId'] = $id; $item['targetId'] = $targetId; $item['targetClassName'] = $safeClassName; $item['icon'] = $config->get('icon'); $item['link'] = $this->getContextLink($targetClass, $targetId); $item = $this->dispatchContextTitle($item, $targetClass); $result[] = $item; } return $result; }
/** * @param OrmResultAfter $event */ public function onResultAfter(OrmResultAfter $event) { $currencies = $this->getCurrencies(); if (!$currencies) { return; } /** @var ResultRecord[] $records */ $records = $event->getRecords(); $productIds = []; foreach ($records as $record) { $productIds[] = $record->getValue('id'); } /** @var ProductPriceRepository $priceRepository */ $priceRepository = $this->doctrineHelper->getEntityRepository('OroB2BPricingBundle:ProductPrice'); $priceList = $this->getPriceList(); $showTierPrices = $this->priceListRequestHandler->getShowTierPrices(); $prices = $priceRepository->findByPriceListIdAndProductIds($priceList->getId(), $productIds, $showTierPrices); $groupedPrices = $this->groupPrices($prices); foreach ($records as $record) { $record->addData(['showTierPrices' => $showTierPrices]); $productId = $record->getValue('id'); $priceContainer = []; foreach ($currencies as $currencyIsoCode) { $columnName = $this->buildColumnName($currencyIsoCode); if (isset($groupedPrices[$productId][$currencyIsoCode])) { $priceContainer[$columnName] = $groupedPrices[$productId][$currencyIsoCode]; } else { $priceContainer[$columnName] = []; } } if ($priceContainer) { $record->addData($priceContainer); } } }
/** * @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); } }
/** * @param WorkflowItem $workflowItem * @return WorkflowItem * @throws WorkflowException */ public function updateAclIdentities(WorkflowItem $workflowItem) { $workflow = $this->workflowRegistry->getWorkflow($workflowItem->getWorkflowName()); $definition = $workflowItem->getDefinition(); $currentStepName = $workflowItem->getCurrentStep()->getName(); $aclIdentities = array(); foreach ($definition->getEntityAcls() as $entityAcl) { if ($entityAcl->getStep()->getName() == $currentStepName) { $attributeName = $entityAcl->getAttribute(); $attribute = $workflow->getAttributeManager()->getAttribute($attributeName); $entity = $workflowItem->getData()->get($attributeName); if (!$entity) { continue; } if (!is_object($entity)) { throw new WorkflowException(sprintf('Value of attribute "%s" must be an object', $attributeName)); } $aclIdentity = new WorkflowEntityAclIdentity(); $aclIdentity->setAcl($entityAcl)->setEntityClass($attribute->getOption('class'))->setEntityId($this->doctrineHelper->getSingleEntityIdentifier($entity)); $aclIdentities[] = $aclIdentity; } } $workflowItem->setAclIdentities($aclIdentities); return $workflowItem; }
/** * @param MarketingList $marketingList * @param array $result * @return MarketingListItem */ public function contactResultRow(MarketingList $marketingList, array $result) { $idName = $this->doctrineHelper->getSingleEntityIdentifierFieldName($marketingList->getEntity()); if (empty($result[$idName])) { throw new \InvalidArgumentException('Result row must contain identifier field'); } return $this->contact($marketingList, $result[$idName]); }
/** * 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)); }
/** * @param DatagridInterface $dataGrid * @return string */ protected function getEntityName(DatagridInterface $dataGrid) { /** @var OrmDatasource $dataSource */ $dataSource = $dataGrid->getDatasource(); $queryBuilder = $dataSource->getQueryBuilder(); $entityName = $queryBuilder->getRootEntities()[0]; return $this->doctrineHelper->getEntityMetadata($entityName)->getName(); }
/** * Checks if the entity can has notes * * @param object $entity * @return bool */ public function isNoteAssociationEnabled($entity) { if (!is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || $this->doctrineHelper->isNewEntity($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)); }
/** * @param null|object $entity * @param bool $attachmentConfigReturn * @param bool $isNewRecord * @param bool $isManaged * @param bool $expected * @dataProvider configResultProvider */ public function testIsAttachmentAssociationEnabled($entity, $attachmentConfigReturn, $isNewRecord, $isManaged, $expected) { $this->attachmentConfig->expects(is_object($entity) && !$isNewRecord ? $this->once() : $this->never())->method('isAttachmentAssociationEnabled')->with($entity)->willReturn($attachmentConfigReturn); $this->doctrineHelper->expects(is_object($entity) && $isManaged ? $this->once() : $this->never())->method('isNewEntity')->willReturn($isNewRecord); $this->doctrineHelper->expects(is_object($entity) ? $this->once() : $this->never())->method('isManageableEntity')->willReturn($isManaged); $actual = $this->filter->isAttachmentAssociationEnabled($entity); $this->assertEquals($expected, $actual); }
protected function setUp() { $this->entityManager = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock(); $this->doctrineHelper = $this->getMockBuilder('Oro\\Bundle\\EntityBundle\\ORM\\DoctrineHelper')->disableOriginalConstructor()->getMock(); $this->doctrineHelper->expects($this->any())->method('getEntityManager')->will($this->returnValue($this->entityManager)); $this->fieldHelper = $this->getMockBuilder('Oro\\Bundle\\ImportExportBundle\\Field\\FieldHelper')->disableOriginalConstructor()->getMock(); $this->fixer = new EntityDetachFixer($this->doctrineHelper, $this->fieldHelper, PropertyAccess::createPropertyAccessor()); }
/** * {@inheritdoc} */ public function normalize(Workflow $workflow, Attribute $attribute, $attributeValue) { if (null === $attributeValue) { return null; } $this->validateAttributeValue($workflow, $attribute, $attributeValue); $identifier = $this->doctrineHelper->getEntityIdentifier($attributeValue); return $identifier ?: null; }