/**
* Add organization field to the search mapping
*
* @param PrepareEntityMapEvent $event
*/
public function prepareEntityMapEvent(PrepareEntityMapEvent $event)
{
$data = $event->getData();
$className = $event->getClassName();
$entity = $event->getEntity();
$organizationId = self::EMPTY_ORGANIZATION_ID;
$metadata = $this->metadataProvider->getMetadata($className);
if ($metadata) {
$organizationField = null;
if ($metadata->getGlobalOwnerFieldName()) {
$organizationField = $metadata->getGlobalOwnerFieldName();
}
if ($metadata->isGlobalLevelOwned()) {
$organizationField = $metadata->getOwnerFieldName();
}
if ($organizationField) {
$propertyAccessor = PropertyAccess::createPropertyAccessor();
/** @var Organization $organization */
$organization = $propertyAccessor->getValue($entity, $organizationField);
if ($organization && null !== $organization->getId()) {
$organizationId = $organization->getId();
}
}
}
$data['integer']['organization'] = $organizationId;
$event->setData($data);
}
/**
* Gets owner of the given entity
*
* @param object $object
* @return object
* @throws \RuntimeException
*/
public function getOwner($object)
{
if (!is_object($object)) {
throw new InvalidEntityException('$object must be an object.');
}
$result = null;
$metadata = $this->metadataProvider->getMetadata($this->entityClassAccessor->getClass($object));
if ($metadata->hasOwner()) {
// at first try to use getOwner method to get the owner
if (method_exists($object, 'getOwner')) {
$result = $object->getOwner();
} else {
// if getOwner method does not exist try to get owner directly from field
try {
$cls = new \ReflectionClass($object);
$ownerProp = $cls->getProperty($metadata->getOwnerFieldName());
if (!$ownerProp->isPublic()) {
$ownerProp->setAccessible(true);
}
$result = $ownerProp->getValue($object);
} catch (\ReflectionException $ex) {
throw new InvalidEntityException(sprintf('$object must have either "getOwner" method or "%s" property.', $metadata->getOwnerFieldName()), 0, $ex);
}
}
}
return $result;
}
public function testClearCacheAll()
{
$configProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock();
$cache = $this->getMockForAbstractClass('Doctrine\\Common\\Cache\\CacheProvider', array(), '', false, true, true, array('deleteAll'));
$provider = new OwnershipMetadataProvider(array('organization' => 'AcmeBundle\\Entity\\Organization', 'business_unit' => 'AcmeBundle\\Entity\\BusinessUnit', 'user' => 'AcmeBundle\\Entity\\User'), $configProvider, null, $cache);
$cache->expects($this->once())->method('deleteAll');
$provider->clearCache();
}
/**
* {@inheritdoc}
*/
public function validate($entity, Constraint $constraint)
{
$className = $this->doctrineHelper->getEntityClass($entity);
$organizationField = $this->metadataProvider->getMetadata($className)->getGlobalOwnerFieldName();
if ($organizationField) {
$constraint->fields = array_merge((array) $constraint->fields, [$organizationField]);
}
parent::validate($entity, $constraint);
}
/**
* @param string $ownerType
* @return string
* @throws \InvalidArgumentException
*/
protected function getOwnerTargetEntityClassName($ownerType)
{
switch ($ownerType) {
case OwnershipType::OWNER_TYPE_USER:
return $this->ownershipMetadataProvider->getUserClass();
case OwnershipType::OWNER_TYPE_BUSINESS_UNIT:
return $this->ownershipMetadataProvider->getBusinessUnitClass();
case OwnershipType::OWNER_TYPE_ORGANIZATION:
return $this->ownershipMetadataProvider->getOrganizationClass();
}
throw new \InvalidArgumentException(sprintf('Unexpected owner type: %s.', $ownerType));
}
/**
* Gets organization of the given entity
*
* @param $object
* @return object|null
* @throws InvalidEntityException
*/
public function getOrganization($object)
{
if (!is_object($object)) {
throw new InvalidEntityException('$object must be an object.');
}
$result = null;
$metadata = $this->metadataProvider->getMetadata(ClassUtils::getClass($object));
if ($metadata->getOrganizationFieldName()) {
$accessor = PropertyAccess::createPropertyAccessor();
$result = $accessor->getValue($object, $metadata->getOrganizationFieldName());
}
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();
}
/**
* Limit segment data by segment's organization
*
* @param Segment $segment
* @param QueryBuilder $qb
*/
protected function applyOrganizationLimit(Segment $segment, QueryBuilder $qb)
{
$organizationField = $this->ownershipMetadataProvider->getMetadata($segment->getEntity())->getGlobalOwnerFieldName();
if ($organizationField) {
$qb->andWhere(sprintf('%s.%s = %s', $qb->getRootAliases()[0], $organizationField, $segment->getOrganization()->getId()));
}
}
/**
* @param string $entityName
* @param Organization $organization
*/
public function setSourceEntityName($entityName, Organization $organization = null)
{
/** @var QueryBuilder $qb */
$queryBuilder = $this->registry->getRepository($entityName)->createQueryBuilder('o');
$metadata = $queryBuilder->getEntityManager()->getClassMetadata($entityName);
foreach (array_keys($metadata->getAssociationMappings()) as $fieldName) {
// can't join with *-to-many relations because they affects query pagination
if ($metadata->isAssociationWithSingleJoinColumn($fieldName)) {
$alias = '_' . $fieldName;
$queryBuilder->addSelect($alias);
$queryBuilder->leftJoin('o.' . $fieldName, $alias);
}
}
foreach ($metadata->getIdentifierFieldNames() as $fieldName) {
$queryBuilder->orderBy('o.' . $fieldName, 'ASC');
}
// Limit data with current organization
if ($organization) {
$organizationField = $this->ownershipMetadata->getMetadata($entityName)->getOrganizationFieldName();
if ($organizationField) {
$queryBuilder->andWhere('o.' . $organizationField . ' = :organization')->setParameter('organization', $organization);
}
}
$this->setSourceQueryBuilder($queryBuilder);
}
/**
* Add organization field to the search mapping
*
* @param PrepareEntityMapEvent $event
*/
public function prepareEntityMapEvent(PrepareEntityMapEvent $event)
{
$data = $event->getData();
$className = $event->getClassName();
$organizationId = self::EMPTY_ORGANIZATION_ID;
$ownerId = self::EMPTY_OWNER_ID;
$metadata = $this->metadataProvider->getMetadata($className);
if ($metadata) {
$entity = $event->getEntity();
$ownerId = $this->getOwnerId($metadata, $entity);
$organizationId = $this->getOrganizationId($metadata, $entity);
}
$data['integer'][sprintf('%s_owner', $event->getEntityMapping()['alias'])] = $ownerId;
$data['integer']['organization'] = $organizationId;
$event->setData($data);
}
/**
* @param $entity - object | class name entity
*
* @return bool|OwnershipMetadataInterface
*/
protected function getMetadataConfig($entity)
{
if (is_object($entity)) {
$entity = ClassUtils::getClass($entity);
}
$metadata = $this->ownershipMetadataProvider->getMetadata($entity);
return $metadata->hasOwner() ? $metadata : false;
}
/**
* Limit data with current organization
*
* @param QueryBuilder $queryBuilder
* @param string $entityName
* @param Organization $organization
*/
protected function addOrganizationLimits(QueryBuilder $queryBuilder, $entityName, Organization $organization = null)
{
if ($organization) {
$organizationField = $this->ownershipMetadata->getMetadata($entityName)->getGlobalOwnerFieldName();
if ($organizationField) {
$queryBuilder->andWhere('o.' . $organizationField . ' = :organization')->setParameter('organization', $organization);
}
}
}
/**
* @param PersistConfigEvent $event
*/
public function prePersistEntityConfig(PersistConfigEvent $event)
{
$event->getConfigManager()->calculateConfigChangeSet($event->getConfig());
$changes = $event->getConfigManager()->getConfigChangeSet($event->getConfig());
$isDeleted = false;
// Now if you press delete entity button, in state variable, in 1st position will be "Deleted" string.
// If you press restore entity, then "Deleted" string will be at 0 position.
if (isset($changes['state']) && $changes['state'][1] === 'Deleted') {
$isDeleted = true;
}
$cp = $event->getConfigManager()->getProvider('ownership');
$className = $event->getConfig()->getId()->getClassName();
if ($cp->hasConfig($className)) {
$this->provider->clearCache($className);
if (!$isDeleted) {
$this->provider->warmUpCache($className);
}
}
}
/**
* Get metadata for entity
*
* @param object|string $entity
*
* @return bool|OwnershipMetadataInterface
* @throws \LogicException
*/
protected function getMetadata($entity)
{
if (is_object($entity)) {
$entity = ClassUtils::getClass($entity);
}
if (!$this->doctrineHelper->isManageableEntity($entity)) {
return false;
}
$metadata = $this->ownershipMetadataProvider->getMetadata($entity);
return $metadata->hasOwner() ? $metadata : false;
}
/**
* @dataProvider getMaxAccessLevelDataProvider
*
* @param $accessLevel
* @param $object
* @param $expectedResult
*/
public function testGetMaxAccessLevel($accessLevel, $object, $expectedResult)
{
if ($object && $accessLevel === AccessLevel::SYSTEM_LEVEL) {
$config = new Config(new EntityConfigId('ownership', 'SomeClass'));
$config->set('owner_type', 'USER')->set('owner_field_name', 'test_field')->set('owner_column_name', 'test_column');
$this->configProvider->expects($this->once())->method('hasConfig')->with('SomeClass')->willReturn(true);
$this->configProvider->expects($this->once())->method('getConfig')->with('SomeClass')->willReturn($config);
}
$this->entityClassResolver = null;
$this->cache = null;
$this->assertEquals($expectedResult, $this->provider->getMaxAccessLevel($accessLevel, $object));
}
/**
* Gets a string represents the type of the given owner
*
* @param mixed $owner
* @return string
*/
protected function getOwnerType($owner)
{
if (is_a($owner, $this->ownershipMetadata->getUserClass())) {
return OwnershipType::OWNER_TYPE_USER;
} elseif (is_a($owner, $this->ownershipMetadata->getBusinessUnitClass())) {
return OwnershipType::OWNER_TYPE_BUSINESS_UNIT;
} elseif (is_a($owner, $this->ownershipMetadata->getOrganizationClass())) {
return OwnershipType::OWNER_TYPE_ORGANIZATION;
} else {
return OwnershipType::OWNER_TYPE_NONE;
}
}
/**
* Gets the id of logged in user
*
* @return int|string
*/
public function getUserId()
{
$token = $this->getSecurityContext()->getToken();
if (!$token) {
return null;
}
$user = $token->getUser();
if (!is_object($user) || !is_a($user, $this->metadataProvider->getUserClass())) {
return null;
}
return $this->objectIdAccessor->getId($user);
}
/**
* @param StaticSegment $staticSegment
* @param QueryBuilder $qb
* @return void
*/
public function prepareMarketingListEntities(StaticSegment $staticSegment, QueryBuilder $qb)
{
if (!$this->memberClassName) {
throw new \InvalidArgumentException('Member class name must be provided');
}
$marketingList = $staticSegment->getMarketingList();
$contactInformationFields = $this->contactInformationFieldsProvider->getMarketingListTypedFields($marketingList, ContactInformationFieldsProvider::CONTACT_INFORMATION_SCOPE_EMAIL);
$expr = $qb->expr()->orX();
foreach ($contactInformationFields as $contactInformationField) {
$contactInformationFieldExpr = $this->fieldHelper->getFieldExpr($marketingList->getEntity(), $qb, $contactInformationField);
$qb->addSelect($contactInformationFieldExpr . ' AS ' . $contactInformationField);
$expr->add($qb->expr()->eq($contactInformationFieldExpr, sprintf('%s.%s', self::MEMBER_ALIAS, self::MEMBER_EMAIL_FIELD)));
}
$organization = $staticSegment->getChannel()->getOrganization();
$metadata = $this->ownershipMetadataProvider->getMetadata($marketingList->getEntity());
if ($organization && ($fieldName = $metadata->getOrganizationFieldName())) {
$aliases = $qb->getRootAliases();
$qb->andWhere($qb->expr()->eq(sprintf('%s.%s', reset($aliases), $fieldName), ':organization'));
$qb->setParameter('organization', $organization);
}
$qb->leftJoin($this->memberClassName, self::MEMBER_ALIAS, Join::WITH, $qb->expr()->andX($expr, $qb->expr()->eq(sprintf('%s.subscribersList', self::MEMBER_ALIAS), ':subscribersList')))->setParameter('subscribersList', $staticSegment->getSubscribersList()->getId());
}
/**
* @dataProvider defaultIntegrationOwnerProvider
*
* @param Integration $integration
* @param string $ownerType
* @param bool $expectedReload
* @param bool $expectedSet
* @param bool $expectedSetOrganization
*/
public function testPopulateChannelOwner(Integration $integration, $ownerType, $expectedReload, $expectedSet, $expectedSetOrganization = false)
{
$entity = new \stdClass();
$owner = $integration->getDefaultUserOwner();
$organization = $integration->getOrganization();
$doctrineMetadata = $this->getMockBuilder('Doctrine\\ORM\\Mapping\\ClassMetadataInfo')->disableOriginalConstructor()->getMock();
$this->em->expects($this->any())->method('getClassMetadata')->will($this->returnValue($doctrineMetadata));
if ($expectedReload) {
$this->uow->expects($this->once())->method('getEntityState')->with($this->identicalTo($owner))->will($this->returnValue(UnitOfWork::STATE_DETACHED));
$this->em->expects($this->once())->method('find')->with($this->equalTo(get_class($owner)))->will($this->returnValue($owner));
}
$ownerMetadata = new OwnershipMetadata($ownerType, self::USER_OWNER_FIELD_NAME, self::USER_OWNER_COLUMN_NAME, self::ORGANIZATION_FIELD_NAME);
$this->metadataProvider->expects($this->any())->method('getMetadata')->with(get_class($entity))->will($this->returnValue($ownerMetadata));
if ($expectedSet) {
$doctrineMetadata->expects($this->once())->method('setFieldValue')->with($this->identicalTo($entity), self::USER_OWNER_FIELD_NAME, $this->identicalTo($owner));
} elseif ($expectedSetOrganization) {
$doctrineMetadata->expects($this->once())->method('setFieldValue')->with($this->identicalTo($entity), self::ORGANIZATION_FIELD_NAME, $this->identicalTo($organization));
} else {
$doctrineMetadata->expects($this->never())->method('setFieldValue');
}
$this->helper->populateChannelOwner($entity, $integration);
}
/**
* Get metadata for entity
*
* @param object|string $entity
* @return bool|OwnershipMetadata
* @throws \LogicException
*/
protected function getMetadata($entity)
{
if (is_object($entity)) {
$dataClassName = ClassUtils::getClass($entity);
} else {
$dataClassName = $entity;
}
$metadata = $this->ownershipMetadataProvider->getMetadata($dataClassName);
if ($metadata->hasOwner()) {
return $metadata;
} else {
return false;
}
}
/**
* @param \PHPUnit_Framework_MockObject_MockObject $qb
* @param object $entity
* @param int|null $id
* @param array $config
* @param AutomaticDiscovery $service
*/
protected function assertDiscoveryCalls($qb, $entity, $id, $config, AutomaticDiscovery $service)
{
$metadata = $this->getMockBuilder('Oro\\Bundle\\SecurityBundle\\Owner\\Metadata\\OwnershipMetadata')->disableOriginalConstructor()->getMock();
$this->metadataProvider->expects($this->any())->method('getMetadata')->willReturn($metadata);
$metadata->expects($this->any())->method('getOrganizationFieldName')->willReturn('organization');
$query = $this->getMockBuilder('Doctrine\\ORM\\AbstractQuery')->disableOriginalConstructor()->setMethods(['getOneOrNullResult'])->getMockForAbstractClass();
$query->expects($this->once())->method('getOneOrNullResult')->will($this->returnValue($entity));
$qb->expects($this->once())->method('getQuery')->will($this->returnValue($query));
$qb->expects($this->any())->method($this->anything())->will($this->returnSelf());
$repository = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$repository->expects($this->once())->method('createQueryBuilder')->with(AutomaticDiscovery::ROOT_ALIAS)->will($this->returnValue($qb));
$this->doctrineHelper->expects($this->once())->method('getSingleEntityIdentifierFieldName')->with($this->entityClass)->will($this->returnValue('id'));
$this->doctrineHelper->expects($this->once())->method('getSingleEntityIdentifier')->with($entity)->will($this->returnValue($id));
$this->doctrineHelper->expects($this->once())->method('getEntityRepository')->with($this->entityClass)->will($this->returnValue($repository));
$this->defaultStrategy->expects($this->once())->method('apply')->with($qb, AutomaticDiscovery::ROOT_ALIAS, 'test1', $config[Configuration::DISCOVERY_NODE], $entity);
/** @var \PHPUnit_Framework_MockObject_MockObject|DiscoveryStrategyInterface $customStrategy */
$customStrategy = $this->getMock('OroCRM\\Bundle\\MagentoBundle\\Service\\AutomaticDiscovery\\DiscoveryStrategyInterface');
$customStrategy->expects($this->once())->method('apply')->with($qb, AutomaticDiscovery::ROOT_ALIAS, 'test2', $config[Configuration::DISCOVERY_NODE], $entity);
$service->addStrategy('test2', $customStrategy);
}
/**
* @param FormBuilderInterface $builder
* @param array $options
* @throws \LogicException when getOwner method isn't implemented for entity with ownership type
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
$dataClassName = $builder->getFormConfig()->getDataClass();
if (!$dataClassName) {
return;
}
$user = $this->getCurrentUser();
if (!$user) {
return;
}
$metadata = $this->ownershipMetadataProvider->getMetadata($dataClassName);
if (!$metadata->hasOwner()) {
return;
}
if (!method_exists($dataClassName, 'getOwner')) {
throw new \LogicException(sprintf('Method getOwner must be implemented for %s entity.', $dataClassName));
}
/**
* TODO: Implement object-based assign check after access levels are supported
*/
$this->isAssignGranted = $this->securityFacade->isGranted('ASSIGN', 'entity:' . $dataClassName);
$defaultOwner = null;
if ($metadata->isUserOwned() && $this->isAssignGranted) {
$this->addUserOwnerField($builder);
$defaultOwner = $user;
} elseif ($metadata->isBusinessUnitOwned()) {
$this->addBusinessUnitOwnerField($builder, $user, $dataClassName);
$defaultOwner = $this->getCurrentBusinessUnit();
} elseif ($metadata->isOrganizationOwned()) {
$this->addOrganizationOwnerField($builder, $user);
$defaultOwner = $this->getCurrentOrganization();
}
/**
* Adding subscriber to hide owner field for update pages if assign permission is not granted
* and set default owner value
*/
$builder->addEventSubscriber(new OwnerFormSubscriber($this->managerRegistry, $this->fieldName, $this->fieldLabel, $this->isAssignGranted, $defaultOwner));
}
/**
* {inheritdoc}
*/
public function clear($cacheDir)
{
$this->provider->clearCache();
}
/**
* {inheritdoc}
*/
public function warmUp($cacheDir)
{
$this->provider->warmUpCache();
}
/**
* Gets metadata for the given domain object
*
* @param object $domainObject
* @return OwnershipMetadata
*/
protected function getObjectMetadata($domainObject)
{
return $this->metadataProvider->getMetadata($this->getObjectClass($domainObject));
}
/**
* {@inheritdoc}
*/
public function getMetadata($className)
{
return isset($this->metadata[$className]) ? $this->metadata[$className] : parent::getMetadata($className);
}
/**
* Gets metadata for the given object
*
* @param mixed $object
*
* @return OwnershipMetadata
*/
protected function getMetadata($object)
{
return $this->metadataProvider->getMetadata($this->getObjectClassName($object));
}
public function __construct(\PHPUnit_Framework_TestCase $testCase)
{
$configProvider = $testCase->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock();
parent::__construct(array('organization' => 'AcmeBundle\\Entity\\Organization', 'business_unit' => 'AcmeBundle\\Entity\\BusinessUnit', 'user' => 'AcmeBundle\\Entity\\User'), $configProvider);
}
/**
* Get metadata for entity
*
* @param string $entityFQCN
*
* @return OwnershipMetadataInterface
*/
protected function getMetadata($entityFQCN)
{
return $this->ownershipMetadataProvider->getMetadata($entityFQCN);
}
