/**
* @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);
}
}
/**
* @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 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;
}
/**
* 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];
}
}
}
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
if ($this->request->get(ProductDataStorage::STORAGE_KEY)) {
$entity = isset($options['data']) ? $options['data'] : null;
if ($entity instanceof $this->dataClass && !$this->doctrineHelper->getSingleEntityIdentifier($entity)) {
$this->fillData($entity);
}
}
}
/**
* Checks if the entity can have activities
*
* @param object|null $entity
* @return bool
*/
public function isApplicable($entity = null)
{
if (null === $entity || !is_object($entity)) {
return false;
}
$entityClass = $this->doctrineHelper->getEntityClass($entity);
$id = $this->doctrineHelper->getSingleEntityIdentifier($entity);
$activityListRepo = $this->doctrine->getRepository('OroActivityListBundle:ActivityList');
return in_array($entityClass, $this->activityListProvider->getTargetEntityClasses()) || (bool) $activityListRepo->getRecordsCountForTargetClassAndId($entityClass, $id);
}
/**
* {@inheritdoc}
*/
public function send(EmailCampaign $campaign, $entity, array $from, array $to)
{
$entityId = $this->doctrineHelper->getSingleEntityIdentifier($entity);
$marketingList = $campaign->getMarketingList();
/** @var EmailTemplate $template */
$template = $campaign->getTransportSettings()->getSettingsBag()->get('template');
list($subjectRendered, $templateRendered) = $this->emailRenderer->compileMessage($template, ['entity' => $entity]);
$emailModel = new Email();
$emailModel->setType($template->getType())->setFrom($this->buildFullEmailAddress($from))->setEntityClass($marketingList->getEntity())->setEntityId($entityId)->setTo($to)->setSubject($subjectRendered)->setBody($templateRendered);
$this->processor->process($emailModel);
}
/**
* Checks if the entity can have activities
*
* @param object|null $entity
* @param int|null $pageType
* @return bool
*/
public function isApplicable($entity = null, $pageType = null)
{
if ($pageType === null || !is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || $this->doctrineHelper->isNewEntity($entity)) {
return false;
}
$pageType = (int) $pageType;
$id = $this->doctrineHelper->getSingleEntityIdentifier($entity);
$entityClass = $this->doctrineHelper->getEntityClass($entity);
$activityListRepo = $this->doctrine->getRepository('OroActivityListBundle:ActivityList');
return $this->isAllowedOnPage($entity, $pageType) && (in_array($entityClass, $this->activityListProvider->getTargetEntityClasses()) || (bool) $activityListRepo->getRecordsCountForTargetClassAndId($entityClass, $id));
}
/**
* @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 object $entity
* @return object|null
*/
protected function refreshEntity($entity)
{
if ($entity instanceof Proxy && !$entity->__isInitialized()) {
$entity->__load();
}
if (!$this->doctrineHelper->getSingleEntityIdentifier($entity)) {
return null;
}
$entityClass = ClassUtils::getClass($entity);
/** @var EntityManager $entityManager */
$entityManager = $this->registry->getManagerForClass($entityClass);
return $entityManager->merge($entity);
}
/**
* {@inheritdoc}
*/
public function normalize($object, $format = null, array $context = array())
{
/** @var ProcessData $object */
$processJob = $this->getProcessJob($context);
$entity = $object['data'];
if (!$entity || $processJob->getProcessTrigger()->getEvent() == ProcessTrigger::EVENT_DELETE) {
$processJob->setEntityId(null);
} else {
$entityId = $this->doctrineHelper->getSingleEntityIdentifier($entity);
$processJob->setEntityId($entityId);
}
return $this->serializer->normalize($object->getValues(), $format, $context);
}
/**
* Set workflow item entity ID
*
* @param LifecycleEventArgs $args
* @throws WorkflowException
*/
protected function updateWorkflowItemEntityRelation(LifecycleEventArgs $args)
{
$workflowItem = $args->getEntity();
if ($workflowItem instanceof WorkflowItem && !$workflowItem->getEntityId()) {
$entity = $workflowItem->getEntity();
if (!$entity) {
throw new WorkflowException('Workflow item does not contain related entity');
}
$entityId = $this->doctrineHelper->getSingleEntityIdentifier($entity);
$workflowItem->setEntityId($entityId);
$unitOfWork = $args->getEntityManager()->getUnitOfWork();
$unitOfWork->scheduleExtraUpdate($workflowItem, array('entityId' => array(null, $entityId)));
}
}
/**
* @param object $entity
* @return object|null
*/
protected function refreshEntity($entity)
{
$entityClass = ClassUtils::getClass($entity);
$entityId = $this->doctrineHelper->getSingleEntityIdentifier($entity);
/** @var EntityManager $entityManager */
$entityManager = $this->registry->getManagerForClass($entityClass);
if (!$entityId) {
return null;
}
if ($entity instanceof Proxy && !$entity->__isInitialized()) {
// We cannot use $entity->__load(); because of bug BAP-7851
return $entityManager->find($entityClass, $entityId);
}
return $entityManager->merge($entity);
}
/**
* @param FormView $view
* @param FormInterface $form
* @param ConfigInterface $extendConfig
*/
protected function addInitialElements(FormView $view, FormInterface $form, ConfigInterface $extendConfig)
{
$data = $form->getData();
if (!is_object($data)) {
return;
}
$dataId = $this->doctrineHelper->getSingleEntityIdentifier($data);
/**
* 0 is default id value for oro_entity_relation
* we need to set it if entity is new
*/
$dataId = $dataId == null ? 0 : $dataId;
/** @var FieldConfigId $extendConfigId */
$extendConfigId = $extendConfig->getId();
$className = $extendConfigId->getClassName();
$fieldName = $extendConfigId->getFieldName();
$view->children[$fieldName]->vars['grid_url'] = $this->router->generate('oro_entity_relation', ['id' => $dataId, 'entityName' => str_replace('\\', '_', $className), 'fieldName' => $fieldName]);
$defaultEntity = null;
if (!$extendConfig->is('without_default')) {
$defaultEntity = FieldAccessor::getValue($data, ExtendConfigDumper::DEFAULT_PREFIX . $fieldName);
}
$selectedCollection = FieldAccessor::getValue($data, $fieldName);
if ($dataId) {
$view->children[$fieldName]->vars['initial_elements'] = $this->getInitialElements($selectedCollection, $defaultEntity, $extendConfig);
}
}
/**
* Checks if the entity can have activities
*
* @param object|null $entity
* @param int|null $pageType
*
* @return bool
*/
public function isApplicable($entity = null, $pageType = null)
{
if (null === $pageType || !is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || $this->doctrineHelper->isNewEntity($entity)) {
return false;
}
$entityClass = $this->doctrineHelper->getEntityClass($entity);
if (isset($this->applicableCache[$entityClass])) {
return $this->applicableCache[$entityClass];
}
$result = false;
if ($this->configManager->hasConfig($entityClass) && $this->isAllowedOnPage($entityClass, $pageType) && $this->hasApplicableActivityAssociations($entityClass)) {
$result = in_array($entityClass, $this->activityListProvider->getTargetEntityClasses(), true) || !$this->isActivityListEmpty($entityClass, $this->doctrineHelper->getSingleEntityIdentifier($entity));
}
$this->applicableCache[$entityClass] = $result;
return $result;
}
/**
* @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();
}
/**
* @param AnalyticsAwareInterface $entity
* @param string $type
* @param int $value
*
* @return int|null
*/
protected function getIndex(AnalyticsAwareInterface $entity, $type, $value)
{
$channel = $entity->getDataChannel();
if (!$channel) {
return null;
}
$channelId = $this->doctrineHelper->getSingleEntityIdentifier($channel);
if (!$channelId) {
return null;
}
$categories = $this->getCategories($channelId, $type);
if (!$categories) {
return null;
}
// null value must be ranked with worse index
if ($value === null) {
/** @var RFMMetricCategory $category */
$category = end($categories);
reset($categories);
return $category->getCategoryIndex();
}
// Search for RFM category that match current value
foreach ($categories as $category) {
$maxValue = $category->getMaxValue();
if ($maxValue && $value > $maxValue) {
continue;
}
$minValue = $category->getMinValue();
if ($minValue !== null && $value <= $category->getMinValue()) {
continue;
}
return $category->getCategoryIndex();
}
return null;
}
/**
* @param object $entity
* @param ActivityListProviderInterface $provider
* @param string $verb
* @param ActivityList|null $list
*
* @return ActivityList
*/
protected function getActivityListEntityForEntity($entity, ActivityListProviderInterface $provider, $verb = ActivityList::VERB_CREATE, $list = null)
{
if ($provider->isApplicable($entity)) {
if (!$list) {
$list = new ActivityList();
}
$list->setSubject($provider->getSubject($entity));
$list->setDescription($this->htmlTagHelper->stripTags($this->htmlTagHelper->purify($provider->getDescription($entity))));
$this->setDate($entity, $provider, $list);
if ($this->hasGrouping($provider)) {
$list->setHead($provider->isHead($entity));
}
$list->setVerb($verb);
if ($verb === ActivityList::VERB_UPDATE) {
$activityListTargets = $list->getActivityListTargetEntities();
foreach ($activityListTargets as $target) {
$list->removeActivityListTarget($target);
}
} else {
$className = $this->doctrineHelper->getEntityClass($entity);
$list->setRelatedActivityClass($className);
$list->setRelatedActivityId($this->doctrineHelper->getSingleEntityIdentifier($entity));
$list->setOrganization($provider->getOrganization($entity));
}
$targets = $provider->getTargetEntities($entity);
foreach ($targets as $target) {
if ($list->supportActivityListTarget($this->doctrineHelper->getEntityClass($target))) {
$list->addActivityListTarget($target);
}
}
return $list;
}
return null;
}
/**
* {@inheritdoc}
*/
public function getActivityId($entity)
{
if ($this->doctrineHelper->getEntityClass($entity) === self::ACL_CLASS) {
$entity = $entity->getEmail();
}
return $this->doctrineHelper->getSingleEntityIdentifier($entity);
}
/**
* @param Channel $channel
* @param string $type
* @param int $value
*
* @return int|null
*/
protected function getIndex(Channel $channel, $type, $value)
{
$channelId = $this->doctrineHelper->getSingleEntityIdentifier($channel);
if (!$channelId) {
return null;
}
$categories = $this->getCategories($channelId, $type);
if (!$categories) {
return null;
}
// null value must be ranked with worse index
if ($value === null) {
return array_pop($categories)->getCategoryIndex();
}
// Search for RFM category that match current value
foreach ($categories as $category) {
$maxValue = $category->getMaxValue();
if ($maxValue && $value > $maxValue) {
continue;
}
$minValue = $category->getMinValue();
if ($minValue !== null && $value <= $minValue) {
continue;
}
return $category->getCategoryIndex();
}
return 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 object $entity
* @return WorkflowItem|null
*/
public function getWorkflowItemByEntity($entity)
{
$entityClass = $this->doctrineHelper->getEntityClass($entity);
$entityIdentifier = $this->doctrineHelper->getSingleEntityIdentifier($entity);
if (false === filter_var($entityIdentifier, FILTER_VALIDATE_INT)) {
return null;
}
return $this->getWorkflowItemRepository()->findByEntityMetadata($entityClass, $entityIdentifier);
}
/**
* @expectedException \Oro\Bundle\EntityBundle\Exception\InvalidEntityException
* @expectedExceptionMessage Can't get single identifier for the entity
*/
public function testGetSingleEntityIdentifierIncorrectIdentifier()
{
$identifiers = array('key1' => 'value1', 'key2' => 'value2');
$entity = new ItemStubProxy();
$class = 'ItemStubProxy';
$this->classMetadata->expects($this->once())->method('getIdentifierValues')->with($entity)->will($this->returnValue($identifiers));
$this->em->expects($this->once())->method('getClassMetadata')->with($class)->will($this->returnValue($this->classMetadata));
$this->registry->expects($this->once())->method('getManagerForClass')->with($class)->will($this->returnValue($this->em));
$this->doctrineHelper->getSingleEntityIdentifier($entity);
}
/**
* {@inheritDoc}
*/
public function normalize($object, $format = null, array $context = array())
{
$processJob = $this->getProcessJob($context);
$entityClass = $this->getClass($object);
$normalizedData = array('className' => $entityClass);
if ($processJob->getProcessTrigger()->getEvent() != ProcessTrigger::EVENT_DELETE) {
$entityId = $this->doctrineHelper->getSingleEntityIdentifier($object);
$normalizedData['entityId'] = $entityId;
return $normalizedData;
}
$normalizedData['entityData'] = array();
$classMetadata = $this->getClassMetadata($entityClass);
$fieldNames = $classMetadata->getFieldNames();
foreach ($fieldNames as $name) {
$value = $classMetadata->getFieldValue($object, $name);
$normalizedData['entityData'][$name] = $this->serializer->normalize($value, $format, $context);
}
return $normalizedData;
}
/**
* {@inheritDoc}
*/
public function transform($value)
{
if ($value !== null && !is_object($value)) {
throw new UnexpectedTypeException($value, 'object');
}
$newEntity = null;
$existingEntity = null;
$mode = $this->defaultMode;
if ($value) {
$identifier = $this->doctrineHelper->getSingleEntityIdentifier($value);
if ($identifier) {
$existingEntity = $value;
$mode = OroEntityCreateOrSelectType::MODE_VIEW;
} else {
$newEntity = $value;
$mode = OroEntityCreateOrSelectType::MODE_CREATE;
}
}
return array('new_entity' => $newEntity, 'existing_entity' => $existingEntity, 'mode' => $mode);
}
/**
* @param EmailOwnerInterface $owner
* @param $data
*
* @return mixed
*/
protected function setOwnerLink($owner, $data)
{
$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;
}
/**
* @param object $object
* @return int|null
*/
protected function getEntityIdentifier($object)
{
if ($object instanceof ObjectIdentityInterface) {
$identifier = $object->getIdentifier();
if (!filter_var($identifier, FILTER_VALIDATE_INT)) {
$identifier = null;
} else {
$identifier = (int) $identifier;
}
} else {
$identifier = $this->doctrineHelper->getSingleEntityIdentifier($object, false);
}
return $identifier;
}
/**
* Add index task to queue
*
* @param object|array $entity
* @return Job[]
*/
protected function createQueueJobs($entity)
{
$entities = $this->getEntitiesArray($entity);
$entityIdentifiers = [];
foreach ($entities as $entity) {
$class = $this->doctrineHelper->getEntityClass($entity);
$identifier = $this->doctrineHelper->getSingleEntityIdentifier($entity);
$entityIdentifiers[$class][] = $identifier;
}
$jobs = [];
foreach ($entityIdentifiers as $class => $identifiers) {
$jobs[] = new Job(IndexCommand::NAME, array_merge([$class], $identifiers));
}
return $jobs;
}
/**
* @param object $entity
* @param $resultType
* @param string $scope
* @return bool
*/
protected function isIdentifierMatched($entity, $resultType, $scope = EntityPaginationManager::VIEW_SCOPE)
{
$entityIds = $this->storage->getEntityIds($entity, $scope);
$currentId = $this->doctrineHelper->getSingleEntityIdentifier($entity);
$matched = false;
switch ($resultType) {
case self::FIRST:
case self::PREVIOUS:
$matched = $currentId != reset($entityIds);
break;
case self::LAST:
case self::NEXT:
$matched = $currentId != end($entityIds);
break;
}
return $matched;
}
/**
* @param FormInterface $form
* @param object $entity
* @param array|callable $saveAndStayRoute
* @param array|callable $saveAndCloseRoute
* @param string $saveMessage
* @param callback|null $resultCallback
* @return array|RedirectResponse
*/
protected function processSave(FormInterface $form, $entity, $saveAndStayRoute, $saveAndCloseRoute, $saveMessage, $resultCallback = null)
{
if ($this->request->get('_wid')) {
$result = $this->getResult($entity, $form, $resultCallback);
$result['savedId'] = $this->doctrineHelper->getSingleEntityIdentifier($entity);
return $result;
} else {
$this->session->getFlashBag()->add('success', $saveMessage);
if (is_callable($saveAndStayRoute)) {
$saveAndStayRoute = call_user_func($saveAndStayRoute, $entity);
}
if (is_callable($saveAndCloseRoute)) {
$saveAndCloseRoute = call_user_func($saveAndCloseRoute, $entity);
}
return $this->router->redirectAfterSave($saveAndStayRoute, $saveAndCloseRoute, $entity);
}
}
