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