/**
* @param StrategyEvent $event
*/
public function onProcessAfter(StrategyEvent $event)
{
$entity = $event->getEntity();
/** @var OwnershipMetadataProvider $metadataProvider */
$metadataProvider = $this->metadataProviderLink->getService();
$organizationField = $metadataProvider->getMetadata(ClassUtils::getClass($entity))->getGlobalOwnerFieldName();
if (!$organizationField) {
return;
}
/** @var SecurityFacade $securityFacade */
$securityFacade = $this->securityFacadeLink->getService();
/**
* We should allow to set organization for entity only in case of console import.
* If import process was executed from UI (grid's import), current organization for entities should be set.
*/
$organization = $this->getPropertyAccessor()->getValue($entity, $organizationField);
if ($organization && $securityFacade->getOrganization() && $organization->getId() == $securityFacade->getOrganizationId()) {
return;
}
$organization = $securityFacade->getOrganization();
if (!$organization) {
$organization = $this->getDefaultOrganization();
}
if (!$organization) {
return;
}
$this->getPropertyAccessor()->setValue($entity, $organizationField, $organization);
}
/**
* Gets context this strategy is working in
*
* @throws \RuntimeException
* @return PermissionGrantingStrategyContextInterface
*/
protected function getContext()
{
if ($this->contextLink === null) {
throw new \RuntimeException('The context link is not set.');
}
return $this->contextLink->getService();
}
/**
* Update attachment entity before upload
*
* @param File $entity
*/
public function preUpload(File $entity)
{
if ($entity->isEmptyFile()) {
if ($this->filesystem->has($entity->getFilename())) {
$this->filesystem->delete($entity->getFilename());
}
$entity->setFilename(null);
$entity->setExtension(null);
$entity->setOriginalFilename(null);
}
if ($entity->getFile() !== null && $entity->getFile()->isFile()) {
$entity->setOwner($this->securityFacadeLink->getService()->getLoggedUser());
$file = $entity->getFile();
if ($entity->getFilename() !== null && $this->filesystem->has($entity->getFilename())) {
$this->filesystem->delete($entity->getFilename());
}
$entity->setExtension($file->guessExtension());
if ($file instanceof UploadedFile) {
$entity->setOriginalFilename($file->getClientOriginalName());
$entity->setMimeType($file->getClientMimeType());
$entity->setFileSize($file->getClientSize());
} else {
$entity->setOriginalFilename($file->getFileName());
$entity->setMimeType($file->getMimeType());
$entity->setFileSize($file->getSize());
}
$entity->setFilename(uniqid() . '.' . $entity->getExtension());
if ($this->filesystem->getAdapter() instanceof MetadataSupporter) {
$this->filesystem->getAdapter()->setMetadata($entity->getFilename(), ['contentType' => $entity->getMimeType()]);
}
}
}
/**
* @param OnClearEventArgs $event
*/
public function onClear(OnClearEventArgs $event)
{
/** @var SecurityContextInterface $securityContext */
$securityContext = $this->securityContextLink->getService();
$className = $event->getEntityClass();
$token = $securityContext->getToken();
if (!$token) {
return;
}
$user = $token->getUser();
if (is_object($user) && (!$className || $className == ClassUtils::getRealClass($user))) {
$user = $this->refreshEntity($user);
if ($user) {
$token->setUser($user);
} else {
$securityContext->setToken(null);
$token = null;
}
}
if ($token && $token instanceof OrganizationContextTokenInterface) {
$organization = $token->getOrganizationContext();
if (is_object($organization) && (!$className || $className == ClassUtils::getRealClass($organization))) {
/** @var Organization $organization */
$organization = $this->refreshEntity($organization);
if ($organization) {
$token->setOrganizationContext($organization);
}
}
}
}
/**
* {@inheritdoc}
*/
public function convertToExportFormat(array $exportedRecord, $skipNullValues = true)
{
if ($this->context->getValue('columns')) {
$columns = $this->context->getValue('columns');
} elseif ($this->context->hasOption('gridName')) {
$gridName = $this->context->getOption('gridName');
$gridConfig = $this->gridManagerLink->getService()->getConfigurationForGrid($gridName);
$columns = $gridConfig->offsetGet('columns');
} else {
throw new InvalidConfigurationException('Configuration of datagrid export processor must contain "gridName" or "columns" options.');
}
if ($this->context->hasOption('gridParameters')) {
$gridParams = $this->context->getOption('gridParameters');
if ($gridParams->has(ColumnsExtension::COLUMNS_PARAM)) {
$columnsParams = $gridParams->get(ColumnsExtension::COLUMNS_PARAM);
$columns = $this->columnsHelper->reorderColumns($columns, $columnsParams);
}
}
$result = [];
foreach ($columns as $columnName => $column) {
if (isset($column['renderable']) && false === $column['renderable']) {
continue;
}
$val = isset($exportedRecord[$columnName]) ? $exportedRecord[$columnName] : null;
$val = $this->applyFrontendFormatting($val, $column);
$result[$this->translator->trans($column['label'])] = $val;
}
return $result;
}
/**
* @param EntityManager $entityManager
*
* @return UserInterface|null
*/
protected function getUser(EntityManager $entityManager)
{
$user = $this->securityFacadeLink->getService()->getLoggedUser();
if ($user && $entityManager->getUnitOfWork()->getEntityState($user) == UnitOfWork::STATE_DETACHED) {
$user = $entityManager->find('OroUserBundle:User', $user->getId());
}
return $user;
}
/**
* {@inheritdoc}
*/
public function isEnabled(Mailbox $mailbox = null)
{
if ($mailbox === null || null === ($organization = $mailbox->getOrganization())) {
$organization = $this->securityLink->getService()->getOrganization();
}
$qb = $this->getChannelRepository()->createQueryBuilder('c');
return (bool) $qb->select('COUNT(c.id)')->join('c.entities', 'e')->andWhere('e.name = :name')->andWhere('c.status = :status')->andWhere('c.owner = :owner')->setParameter('name', static::LEAD_CLASS)->setParameter('status', Channel::STATUS_ACTIVE)->setParameter('owner', $organization)->getQuery()->getSingleScalarResult();
}
/**
* {@inheritdoc}
*/
public function getNameDQL($format, $locale, $className, $alias)
{
if ($format === self::FULL && $this->isFullFormatSupported($className)) {
/** @var DQLNameFormatter $dqlNameFormatter */
$dqlNameFormatter = $this->dqlNameFormatterLink->getService();
return $dqlNameFormatter->getFormattedNameDQL($alias, $className, $locale);
}
return false;
}
/**
* @param PreUpdateEventArgs $eventArgs
*/
public function preUpdate(PreUpdateEventArgs $eventArgs)
{
if ($eventArgs->getEntity() instanceof RoleInterface && $eventArgs->hasChangedField('role')) {
$oldRoleName = $eventArgs->getOldValue('role');
$newRoleName = $eventArgs->getNewValue('role');
/** @var $aclSidManager AclSidManager */
$aclSidManager = $this->aclSidManagerLink->getService();
$aclSidManager->updateSid($aclSidManager->getSid($newRoleName), $oldRoleName);
}
}
/**
* {@inheritdoc}
*/
public function checkPreAuth(UserInterface $user)
{
parent::checkPreAuth($user);
if ($user instanceof User && null !== $this->securityContextLink->getService()->getToken() && null !== $user->getPasswordChangedAt() && null !== $user->getLastLogin() && $user->getPasswordChangedAt() > $user->getLastLogin()) {
$this->flashBag->add('error', $this->translator->trans('oro.user.security.password_changed.message'));
$exception = new PasswordChangedException('Invalid password.');
$exception->setUser($user);
throw $exception;
}
}
/**
* Set up specific environment for package manager
*
* @return PackageManager
*/
protected function getPackageManager()
{
// avoid exception in Composer\Factory for creation service oro_distribution.composer
if (!getenv('COMPOSER_HOME') && !getenv('HOME')) {
putenv(sprintf('COMPOSER_HOME=%s', $this->composerCacheHome));
// avoid change of current directory, just give correct vendor dir
$rootPath = realpath($this->kernelRootDir . '/../') . DIRECTORY_SEPARATOR;
Config::$defaultConfig['vendor-dir'] = $rootPath . Config::$defaultConfig['vendor-dir'];
}
return $this->pmLink->getService();
}
/**
* @param LoadClassMetadataEventArgs $event
*/
public function loadClassMetadata(LoadClassMetadataEventArgs $event)
{
$classMetadata = $event->getClassMetadata();
$className = $classMetadata->getName();
/** @var ExtendMetadataBuilder $metadataBuilder */
$metadataBuilder = $this->metadataBuilderServiceLink->getService();
if ($metadataBuilder->supports($className)) {
$classMetadataBuilder = new ClassMetadataBuilder($classMetadata);
$metadataBuilder->build($classMetadataBuilder, $className);
$event->getEntityManager()->getMetadataFactory()->setMetadataFor($className, $classMetadata);
}
}
/**
* {@inheritdoc}
*/
public function onFlush(OnFlushEventArgs $event)
{
// check for logged user is for confidence that data changes comes from UI, not from sync process.
if ($this->securityFacadeLink->getService()->hasLoggedUser()) {
$em = $event->getEntityManager();
$this->processUpdates($em);
$this->processDeletesAndCollections($em);
while (null !== ($magentoCustomer = array_pop($this->processIds))) {
$this->schedulerServiceLink->getService()->schedule($magentoCustomer->getChannel(), 'customer', ['id' => $magentoCustomer->getId()], false);
}
}
}
/**
* @param ActivityListProviderInterface $provider
* @param $mapFields
*
* @return Criteria
*/
protected function getCriteriaByProvider(ActivityListProviderInterface $provider, $mapFields)
{
$activityClass = $provider->getActivityClass();
$aclClass = $provider->getAclClass();
$criteria = new Criteria();
$appliedCriteria = $this->aclHelper->applyAclToCriteria($aclClass, $criteria, 'VIEW', $mapFields);
$isGranted = $this->securityContextLink->getService()->isGranted('VIEW', 'entity:' . $aclClass);
if ($isGranted) {
$appliedCriteria->andWhere(Criteria::expr()->eq('relatedActivityClass', $activityClass));
}
return $appliedCriteria;
}
/**
* @ActivityListQueryDesigner $queryDesigner
*
* @return DatagridInterface
*/
public function createGrid(ActivityListQueryDesigner $source)
{
$this->datagridConfigurationBuilder->setGridName('related-activity');
$this->datagridConfigurationBuilder->setSource($source);
$config = $this->datagridConfigurationBuilder->getConfiguration();
$stopPropagationListener = function (Event $e) {
$e->stopPropagation();
};
$this->eventDispatcher->addListener(BuildBefore::NAME, $stopPropagationListener, 255);
$grid = $this->gridBuilderLink->getService()->build($config, new ParameterBag());
$this->eventDispatcher->removeListener(BuildBefore::NAME, $stopPropagationListener);
return $grid;
}
/**
* {@inheritdoc}
*/
public function search($query, $page, $perPage, $searchById = false)
{
$user = $this->securityContextLink->getService()->getToken()->getUser();
$repository = $this->managerRegistry->getRepository($this->className);
if (!$searchById) {
$items = $repository->getEnabledUserOrganizationsByName($user, $query);
} else {
$items = $repository->getEnabledUserOrganizationById($user, $query);
}
$resultsData = [];
foreach ($items as $organization) {
$resultsData[] = $this->convertItem($organization);
}
return ['results' => $resultsData, 'more' => false];
}
/**
* @return Organization|null
*/
protected function getOrganization()
{
/** @var SecurityContextInterface $securityContext */
$securityContext = $this->securityContextLink->getService();
$token = $securityContext->getToken();
return $token instanceof OrganizationContextTokenInterface ? $token->getOrganizationContext() : null;
}
/**
* Get cache ID for given organization id. If id was not set, get cache ID depending on the current organization
*
* @param int $organizationId
* @return string
*/
protected function getCacheId($organizationId = null)
{
if (!$organizationId) {
$organizationId = $this->securityFacadeLink->getService()->getOrganizationId();
}
return self::CACHE_ID . '_' . $organizationId;
}
/**
* We should limit data with current organization
*
* @param string $entityName
* @return bool
*/
protected function shouldBeAddedOrganizationLimits($entityName)
{
if (!array_key_exists($entityName, $this->organizationLimitsByEntity)) {
$this->organizationLimitsByEntity[$entityName] = $this->securityFacadeLink->getService()->getOrganization() && $this->ownershipMetadataProviderLink->getService()->getMetadata($entityName)->getOrganizationFieldName();
}
return $this->organizationLimitsByEntity[$entityName];
}
/**
* {@inheritdoc}
*/
public function getActivityOwners($entity, ActivityList $activityList)
{
$entity = $this->getEmailEntity($entity);
$filter = ['email' => $entity];
$targetEntities = $this->getTargetEntities($entity);
$organizations = [$this->getOrganization($entity)];
$propertyAccessor = PropertyAccess::createPropertyAccessor();
foreach ($targetEntities as $target) {
try {
$organizations[] = $propertyAccessor->getValue($target, 'organization');
} catch (\Exception $e) {
// skipp target
}
}
if (count($organizations) > 0) {
$filter['organization'] = $organizations;
}
$activityArray = [];
/** @var EmailUser[] $owners */
$owners = $this->doctrineRegistryLink->getService()->getRepository('OroEmailBundle:EmailUser')->findBy($filter);
if ($owners) {
foreach ($owners as $owner) {
if ($owner->getOrganization() && $owner->getOwner()) {
$activityOwner = new ActivityOwner();
$activityOwner->setActivity($activityList);
$activityOwner->setOrganization($owner->getOrganization());
$activityOwner->setUser($owner->getOwner());
$activityArray[] = $activityOwner;
}
}
}
return $activityArray;
}
/**
* {@inheritdoc}
*/
public function getGroupedEntities($email)
{
/** @var QueryBuilder $queryBuilder */
$queryBuilder = $this->doctrineRegistryLink->getService()->getRepository('OroActivityListBundle:ActivityList')->createQueryBuilder('a');
$queryBuilder->innerJoin('OroEmailBundle:Email', 'e', 'INNER', 'a.relatedActivityId = e.id and a.relatedActivityClass = :class')->setParameter('class', self::ACTIVITY_CLASS)->andWhere('e.thread = :thread')->setParameter('thread', $email->getThread());
return $queryBuilder->getQuery()->getResult();
}
/**
* @param EntityManager $entityManager
* @param TranslatorInterface $translator
* @param SecurityContext $securityContext
* @param ServiceLink $securityFacadeLink
* @param EmailManager $emailManager
*/
public function __construct(EntityManager $entityManager, TranslatorInterface $translator, SecurityContext $securityContext, ServiceLink $securityFacadeLink, EmailManager $emailManager)
{
$this->entityManager = $entityManager;
$this->translator = $translator;
$this->securityContext = $securityContext;
$this->user = $this->securityContext->getToken()->getUser();
$this->securityFacade = $securityFacadeLink->getService();
$this->emailManager = $emailManager;
}
/**
* Schedules EmailBody for processing.
*
* @param EmailBody $emailBody
*/
protected function scheduleProcess(EmailBody $emailBody)
{
/*
* Retrieve all process definitions to trigger
*/
$definitions = $this->processStorage->getService()->getProcessDefinitionNames();
$definitions = $this->getDefinitionRepository()->findBy(['name' => $definitions]);
/*
* Trigger process definitions with provided data
*/
foreach ($definitions as $definition) {
$trigger = new ProcessTrigger();
$trigger->setDefinition($definition);
$data = new ProcessData();
$data->set('data', $emailBody);
$this->handler->handleTrigger($trigger, $data);
}
}
/**
* @param EmailAttachmentManager $attachmentManager
* @param ConfigProvider $configProvider
* @param EmailActivityListProvider $activityListProvider
* @param ServiceLink $securityFacadeLink
* @param ActivityListChainProvider $chainProvider
* @param EntityManager $entityManager
*/
public function __construct(EmailAttachmentManager $attachmentManager, ConfigProvider $configProvider, EmailActivityListProvider $activityListProvider, ServiceLink $securityFacadeLink, ActivityListChainProvider $chainProvider, EntityManager $entityManager)
{
$this->attachmentManager = $attachmentManager;
$this->configProvider = $configProvider;
$this->activityListProvider = $activityListProvider;
$this->securityFacade = $securityFacadeLink->getService();
$this->chainProvider = $chainProvider;
$this->entityManager = $entityManager;
}
/**
* @param object $entity
* @return string
*/
protected function getOrganizationField($entity)
{
$entityName = ClassUtils::getClass($entity);
if (!array_key_exists($entityName, $this->organizationFieldByEntity)) {
/** @var OwnershipMetadataProvider $metadataProvider */
$metadataProvider = $this->metadataProviderLink->getService();
$this->organizationFieldByEntity[$entityName] = $metadataProvider->getMetadata($entityName)->getGlobalOwnerFieldName();
}
return $this->organizationFieldByEntity[$entityName];
}
/**
* {@inheritdoc}
*/
public function setImportExportContext(ContextInterface $context)
{
$this->context = $context;
if ($context->hasOption('gridName')) {
$this->grid = $this->gridManagerLink->getService()->getDatagrid($context->getOption('gridName'), $context->getOption('gridParameters'));
$context->setValue('columns', $this->grid->getConfig()->offsetGet('columns'));
} else {
throw new InvalidConfigurationException('Configuration of datagrid export reader must contain "gridName".');
}
}
/**
* @param DoctrineHelper $doctrineHelper
* @param \Swift_Mailer $mailer
* @param EmailAddressHelper $emailAddressHelper
* @param EmailEntityBuilder $emailEntityBuilder
* @param EmailOwnerProvider $emailOwnerProvider
* @param EmailActivityManager $emailActivityManager
* @param ServiceLink $serviceLink
* @param EventDispatcherInterface $eventDispatcher
*/
public function __construct(DoctrineHelper $doctrineHelper, \Swift_Mailer $mailer, EmailAddressHelper $emailAddressHelper, EmailEntityBuilder $emailEntityBuilder, EmailOwnerProvider $emailOwnerProvider, EmailActivityManager $emailActivityManager, ServiceLink $serviceLink, EventDispatcherInterface $eventDispatcher)
{
$this->doctrineHelper = $doctrineHelper;
$this->mailer = $mailer;
$this->emailAddressHelper = $emailAddressHelper;
$this->emailEntityBuilder = $emailEntityBuilder;
$this->emailOwnerProvider = $emailOwnerProvider;
$this->emailActivityManager = $emailActivityManager;
$this->securityFacade = $serviceLink->getService();
$this->eventDispatcher = $eventDispatcher;
}
/**
* @param object $entity
*/
protected function updateOrganization($entity)
{
/** @var OwnershipMetadataProvider $metadataProvider */
$metadataProvider = $this->metadataProviderLink->getService();
$organizationField = $metadataProvider->getMetadata(ClassUtils::getClass($entity))->getGlobalOwnerFieldName();
if (!$organizationField) {
return;
}
$organization = $this->getPropertyAccessor()->getValue($entity, $organizationField);
if ($organization) {
return;
}
/** @var SecurityFacade $securityFacade */
$securityFacade = $this->securityFacadeLink->getService();
$organization = $securityFacade->getOrganization();
if (!$organization) {
return;
}
$this->getPropertyAccessor()->setValue($entity, $organizationField, $organization);
}
/**
* Schedules EmailBody for processing.
*
* @param EmailBody $emailBody
*/
protected function scheduleProcess(EmailBody $emailBody)
{
/*
* Retrieve all process definitions to trigger
*/
$definitions = $this->processStorage->getService()->getProcessDefinitionNames();
$definitions = $this->getDefinitionRepository()->findBy(['name' => $definitions]);
/*
* Trigger process definitions with provided data
*/
foreach ($definitions as $definition) {
$trigger = new ProcessTrigger();
//id must be unique otherwise in cache will be saved and runned first definition with id = null
$trigger->setId($definition->getName());
$trigger->setDefinition($definition);
$data = new ProcessData();
$data->set('data', $emailBody);
$this->handler->handleTrigger($trigger, $data);
}
}
/**
* @param WidgetConfigurationLoadEvent $event
*/
public function onWidgetConfigurationLoad(WidgetConfigurationLoadEvent $event)
{
$configuration = $event->getConfiguration();
if (!isset($configuration['route'], $configuration['route_parameters'], $configuration['route_parameters']['gridName']) || $configuration['route'] !== 'oro_dashboard_grid') {
return;
}
$gridName = $configuration['route_parameters']['gridName'];
$gridConfiguration = $this->datagridManagerLink->getService()->getConfigurationForGrid($gridName);
$datagrid = $this->datagridBuilder->build($gridConfiguration, new ParameterBag());
$metadata = $datagrid->getMetadata();
$choices = $metadata->offsetGetByPath('[gridViews][choices]', []);
$viewChoices = [];
foreach ($choices as $choice) {
$viewChoices[$choice['value']] = $choice['label'];
}
if (!isset($configuration['fields'])) {
$configuration['fields'] = [];
}
$configuration['configuration'] = array_merge($configuration['configuration'], ['gridView' => ['type' => 'choice', 'options' => ['label' => 'oro.dashboard.grid.fields.grid_view.label', 'choices' => $viewChoices], 'show_on_widget' => false]]);
$event->setConfiguration($configuration);
}
