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