PHP Utils\ServiceLink类代码示例

 /**
  * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
  */
 protected function setUp()
 {
     $this->em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
     $this->doctrineHelper = $this->getMockBuilder('Oro\\Bundle\\EntityBundle\\ORM\\DoctrineHelper')->disableOriginalConstructor()->getMock();
     $this->mailer = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Mailer\\DirectMailer')->disableOriginalConstructor()->getMock();
     $this->mailerTransport = $this->getMockBuilder('\\Swift_Transport_EsmtpTransport')->disableOriginalConstructor()->getMock();
     $this->mailer->expects($this->any())->method('getTransport')->will($this->returnValue($this->mailerTransport));
     $this->emailEntityBuilder = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Builder\\EmailEntityBuilder')->disableOriginalConstructor()->getMock();
     $this->emailOwnerProvider = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\Provider\\EmailOwnerProvider')->disableOriginalConstructor()->getMock();
     $this->dispatcher = $this->getMockBuilder('Symfony\\Component\\EventDispatcher\\EventDispatcherInterface')->disableOriginalConstructor()->getMock();
     $this->emailActivityManager = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\Manager\\EmailActivityManager')->disableOriginalConstructor()->getMock();
     $this->securityFacade = $this->getMockBuilder('Oro\\Bundle\\SecurityBundle\\SecurityFacade')->setMethods(['getLoggedUser', 'getOrganization'])->disableOriginalConstructor()->getMock();
     $this->userEmailOrigin = $this->getMockBuilder('Oro\\Bundle\\ImapBundle\\Entity\\UserEmailOrigin')->disableOriginalConstructor()->getMock();
     $this->userEmailOrigin->expects($this->any())->method('getSmtpHost')->will($this->returnValue('abc'));
     $this->userEmailOrigin->expects($this->any())->method('getSmtpPort')->will($this->returnValue(25));
     $this->securityFacadeLink = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\DependencyInjection\\Utils\\ServiceLink')->setMethods(['getService'])->disableOriginalConstructor()->getMock();
     $this->securityFacadeLink->expects($this->any())->method('getService')->will($this->returnValue($this->securityFacade));
     $this->securityFacade->expects($this->any())->method('getOrganization')->will($this->returnValue($this->getTestOrganization()));
     $this->doctrineHelper->expects($this->any())->method('getEntityManager')->with('OroEmailBundle:Email')->will($this->returnValue($this->em));
     $folder = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\EmailFolder')->disableOriginalConstructor()->getMock();
     $this->userEmailOrigin->expects($this->any())->method('getFolder')->with(FolderType::SENT)->will($this->returnValue($folder));
     $emailOriginRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
     $emailOriginRepo->expects($this->any())->method('findOneBy')->with(['internalName' => InternalEmailOrigin::BAP])->will($this->returnValue($this->userEmailOrigin));
     $this->em->expects($this->any())->method('getRepository')->with('OroEmailBundle:InternalEmailOrigin')->will($this->returnValue($emailOriginRepo));
     $this->emailProcessor = new Processor($this->doctrineHelper, $this->mailer, new EmailAddressHelper(), $this->emailEntityBuilder, $this->emailOwnerProvider, $this->emailActivityManager, $this->securityFacadeLink, $this->dispatcher, new Mcrypt());
 }

 protected function setUp()
 {
     $this->service = $this->getMockBuilder('Symfony\\Component\\Security\\Core\\SecurityContext')->disableOriginalConstructor()->getMock();
     $this->securityContextLink = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\DependencyInjection\\Utils\\ServiceLink')->disableOriginalConstructor()->getMock();
     $this->securityContextLink->expects($this->any())->method('getService')->willReturn($this->service);
     $this->flashBag = $this->getMock('Symfony\\Component\\HttpFoundation\\Session\\Flash\\FlashBagInterface');
     $this->userChecker = new UserChecker($this->securityContextLink, $this->flashBag);
 }

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

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

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

 public function setUp()
 {
     $this->configProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock();
     $this->emailAttachmentManager = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Manager\\EmailAttachmentManager')->disableOriginalConstructor()->getMock();
     $this->activityListProvider = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Provider\\EmailActivityListProvider')->disableOriginalConstructor()->getMock();
     $this->securityFacadeLink = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\DependencyInjection\\Utils\\ServiceLink')->disableOriginalConstructor()->getMock();
     $this->securityFacade = $this->getMockBuilder('Oro\\Bundle\\SecurityBundle\\SecurityFacade')->disableOriginalConstructor()->getMock();
     $this->securityFacadeLink->expects($this->once())->method('getService')->willReturn($this->securityFacade);
     $this->chainProvider = $this->getMockBuilder('Oro\\Bundle\\ActivityListBundle\\Provider\\ActivityListChainProvider')->disableOriginalConstructor()->getMock();
     $this->entityManager = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
     $this->listener = new EmailBodyAddListener($this->emailAttachmentManager, $this->configProvider, $this->activityListProvider, $this->securityFacadeLink, $this->chainProvider, $this->entityManager);
 }

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

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

 /**
  * 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()]);
         }
     }
 }

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