/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
if (empty($options['data_class'])) {
return;
}
$className = $options['data_class'];
if (!$this->doctrineHelper->isManageableEntity($className)) {
return;
}
if (!$this->entityConfigProvider->hasConfig($className)) {
return;
}
$uniqueKeys = $this->entityConfigProvider->getConfig($className)->get('unique_key');
if (empty($uniqueKeys)) {
return;
}
/* @var \Symfony\Component\Validator\Mapping\ClassMetadata $validatorMetadata */
$validatorMetadata = $this->validator->getMetadataFor($className);
foreach ($uniqueKeys['keys'] as $uniqueKey) {
$fields = $uniqueKey['key'];
$labels = array_map(function ($fieldName) use($className) {
$label = $this->entityConfigProvider->getConfig($className, $fieldName)->get('label');
return $this->translator->trans($label);
}, $fields);
$constraint = new UniqueEntity(['fields' => $fields, 'errorPath' => '', 'message' => $this->translator->transChoice('oro.entity.validation.unique_field', sizeof($fields), ['%field%' => implode(', ', $labels)])]);
$validatorMetadata->addConstraint($constraint);
}
}
/**
* {@inheritdoc}
*/
public function process(ContextInterface $context)
{
/** @var ConfigContext $context */
$definition = $context->getResult();
if (empty($definition)) {
// an entity configuration does not exist
return;
}
$entityClass = $context->getClassName();
if (!isset($definition[ConfigUtil::LABEL])) {
$entityName = $this->entityClassNameProvider->getEntityClassName($entityClass);
if ($entityName) {
$definition[ConfigUtil::LABEL] = $entityName;
}
}
if (!isset($definition[ConfigUtil::PLURAL_LABEL])) {
$entityPluralName = $this->entityClassNameProvider->getEntityClassPluralName($entityClass);
if ($entityPluralName) {
$definition[ConfigUtil::PLURAL_LABEL] = $entityPluralName;
}
}
if (!isset($definition[ConfigUtil::DESCRIPTION]) && $this->entityConfigProvider->hasConfig($entityClass)) {
$definition[ConfigUtil::DESCRIPTION] = new Label($this->entityConfigProvider->getConfig($entityClass)->get('description'));
}
$context->setResult($definition);
}
/**
* Handle prePersist.
*
* @param LifecycleEventArgs $args
* @throws \LogicException when getOwner method isn't implemented for entity with ownership type
*/
public function prePersist(LifecycleEventArgs $args)
{
$token = $this->getSecurityContext()->getToken();
if (!$token) {
return;
}
$user = $token->getUser();
if (!$user) {
return;
}
$entity = $args->getEntity();
$className = ClassUtils::getClass($entity);
if ($this->configProvider->hasConfig($className)) {
$accessor = PropertyAccess::createPropertyAccessor();
$config = $this->configProvider->getConfig($className);
$ownerType = $config->get('owner_type');
$ownerFieldName = $config->get('owner_field_name');
// set default owner for organization and user owning entities
if ($ownerType && in_array($ownerType, [OwnershipType::OWNER_TYPE_ORGANIZATION, OwnershipType::OWNER_TYPE_USER]) && !$accessor->getValue($entity, $ownerFieldName)) {
$owner = null;
if (OwnershipType::OWNER_TYPE_USER == $ownerType) {
$owner = $user;
} elseif (OwnershipType::OWNER_TYPE_ORGANIZATION == $ownerType && $token instanceof OrganizationContextTokenInterface) {
$owner = $token->getOrganizationContext();
}
$accessor->setValue($entity, $ownerFieldName, $owner);
}
//set organization
$this->setDefaultOrganization($token, $config, $entity);
}
}
/**
* Handle prePersist.
*
* @param LifecycleEventArgs $args
* @throws \LogicException when getOwner method isn't implemented for entity with ownership type
*/
public function prePersist(LifecycleEventArgs $args)
{
$token = $this->getSecurityContext()->getToken();
if (!$token) {
return;
}
$user = $token->getUser();
if (!$user) {
return;
}
$entity = $args->getEntity();
if ($this->configProvider->hasConfig(get_class($entity))) {
$config = $this->configProvider->getConfig(get_class($entity));
$ownerType = $config->get('owner_type');
if ($ownerType && $ownerType !== OwnershipType::OWNER_TYPE_NONE) {
if (!method_exists($entity, 'getOwner')) {
throw new \LogicException(sprintf('Method getOwner must be implemented for %s entity', get_class($entity)));
}
if (!$entity->getOwner()) {
/**
* Automatically set current user as record owner
*/
if (OwnershipType::OWNER_TYPE_USER == $ownerType && method_exists($entity, 'setOwner')) {
$entity->setOwner($user);
}
}
}
}
}
/**
* Checks if the entity can have comments
*
* @param object|null $entity
*
* @return bool
*/
public function isApplicable($entity)
{
if (!is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || !$this->securityFacade->isGranted('oro_comment_view')) {
return false;
}
$className = ClassUtils::getClass($entity);
return $this->commentConfigProvider->hasConfig($className) && $this->commentConfigProvider->getConfig($className)->is('enabled') && $this->entityConfigProvider->hasConfig(Comment::ENTITY_NAME, ExtendHelper::buildAssociationName($className));
}
/**
* @param mixed $entity
* @param bool $show
*
* @return bool
*/
public function isEntityAuditable($entity, $show)
{
if ($show || !is_object($entity)) {
return $show;
}
$className = ClassUtils::getClass($entity);
return $this->configProvider->hasConfig($className) && $this->configProvider->getConfig($className)->is('auditable');
}
/**
* Checks if the entity can has notes
*
* @param object $entity
* @return bool
*/
public function isAttachmentAssociationEnabled($entity)
{
if (null === $entity || !is_object($entity)) {
return false;
}
$className = ClassUtils::getClass($entity);
return $this->attachmentConfigProvider->hasConfig($className) && $this->attachmentConfigProvider->getConfig($className)->is('enabled') && $this->entityConfigProvider->hasConfig(AttachmentScope::ATTACHMENT, ExtendHelper::buildAssociationName($className));
}
/**
* Gets translated field name by its name
*
* @param string $className
* @param string $fieldName
*
* @return string
*/
protected function getFieldLabel($className, $fieldName)
{
if (!$this->entityConfigProvider->hasConfig($className, $fieldName)) {
return $fieldName;
}
$fieldLabel = $this->entityConfigProvider->getConfig($className, $fieldName)->get('label');
return $this->translator->trans($fieldLabel);
}
/**
* Checks if the entity can be shared
*
* @param object $entity
* @return bool
*/
public function isShareEnabled($entity)
{
if (null === $entity || !is_object($entity)) {
return false;
}
$className = ClassUtils::getClass($entity);
return $this->securityFacade->isGranted('SHARE', $entity) && $this->configProvider->hasConfig($className) && $this->configProvider->getConfig($className)->get('share_scopes');
}
/**
* Checks if the entity can has notes
*
* @param object $entity
* @return bool
*/
public function isNoteAssociationEnabled($entity)
{
if (null === $entity || !is_object($entity)) {
return false;
}
$className = ClassUtils::getClass($entity);
return $this->noteConfigProvider->hasConfig($className) && $this->noteConfigProvider->getConfig($className)->is('enabled') && $this->entityConfigProvider->hasConfig(Note::ENTITY_NAME, ExtendHelper::buildAssociationName($className));
}
/**
* {@inheritdoc}
*/
public function supports(array $schema)
{
if (!$this->groupingConfigProvider->hasConfig($schema['class'])) {
return false;
}
$groups = $this->groupingConfigProvider->getConfig($schema['class'])->get('groups');
return !empty($groups) && in_array(ActivityScope::GROUP_ACTIVITY, $groups);
}
/**
* Indicates whether the given entity type can be associated with the given activity or not
*
* @param string $entityClass
* @param string $activityEntityClass
*
* @return bool
*/
public function hasActivityAssociation($entityClass, $activityEntityClass)
{
if (!$this->activityConfigProvider->hasConfig($entityClass)) {
return false;
}
$activityClassNames = $this->activityConfigProvider->getConfig($entityClass)->get('activities');
return !empty($activityClassNames) && in_array($activityEntityClass, $activityClassNames);
}
/**
* @param $entity
* @return string
*/
public function getOwnerType($entity)
{
$ownerClassName = ClassUtils::getRealClass(get_class($entity));
if (!$this->configProvider->hasConfig($ownerClassName)) {
return;
}
$config = $this->configProvider->getConfig($ownerClassName)->all();
return $config['owner_type'];
}
/**
* @param object $entity
* @return string
*/
public function getOwnerType($entity)
{
$ownerClassName = ClassUtils::getRealClass($entity);
if (!$this->configProvider->hasConfig($ownerClassName)) {
return null;
}
$config = $this->configProvider->getConfig($ownerClassName);
return $config->get('owner_type');
}
/**
* @param ResultRecordInterface $record
* @return array
*/
public function getWorkflowDefinitionPermissions(ResultRecordInterface $record)
{
$isActiveWorkflow = false;
$relatedEntity = $record->getValue('entityClass');
if ($this->configProvider->hasConfig($relatedEntity)) {
$config = $this->configProvider->getConfig($relatedEntity);
$isActiveWorkflow = $record->getValue('name') == $config->get('active_workflow');
}
$isSystem = $record->getValue('system');
return array('activate' => !$isActiveWorkflow, 'clone' => true, 'deactivate' => $isActiveWorkflow, 'delete' => !$isSystem, 'update' => !$isSystem, 'view' => true);
}
/**
* @param string $entityName
* @return string|null
*/
protected function getEntityGridName($entityName)
{
$gridName = null;
if ($this->configProvider->hasConfig($entityName)) {
$config = $this->configProvider->getConfig($entityName);
$gridName = $config->get('grid_name');
}
if (!$gridName) {
throw new \RuntimeException(sprintf('Grid not found for entity "%s"', $entityName));
}
return $gridName;
}
/**
* @param FormInterface $field
* @param FormView $view
*/
protected function updateTooltip(FormInterface $field, FormView $view)
{
$parentOptions = $field->getParent()->getConfig()->getOptions();
$parentClassName = isset($parentOptions['data_class']) ? $parentOptions['data_class'] : null;
if (!isset($view->vars['tooltip']) && $parentClassName && $this->entityConfigProvider->hasConfig($parentClassName, $field->getName())) {
$tooltip = $this->entityConfigProvider->getConfig($parentClassName, $field->getName())->get('description');
//@deprecated 1.9.0:1.11.0 tooltips.*.yml will be removed. Use Resources/translations/messages.*.yml instead
if ($this->translator->hasTrans($tooltip, self::DEFAULT_TRANSLATE_DOMAIN) || $this->translator->hasTrans($tooltip, self::TOOLTIPS_TRANSLATE_DOMAIN)) {
$view->vars['tooltip'] = $tooltip;
}
}
}
public function testConfig()
{
$this->assertEquals($this->configManager, $this->configProvider->getConfigManager());
$this->assertEquals(true, $this->configProvider->hasConfig(DemoEntity::ENTITY_NAME));
$this->assertEquals($this->entityConfig, $this->configProvider->getConfig(DemoEntity::ENTITY_NAME));
$this->assertEquals('testScope', $this->configProvider->getScope());
$entityConfigId = new EntityConfigId('testScope', DemoEntity::ENTITY_NAME);
$fieldConfigId = new FieldConfigId('testScope', DemoEntity::ENTITY_NAME, 'testField', 'string');
$this->assertEquals($entityConfigId, $this->configProvider->getId(DemoEntity::ENTITY_NAME));
$this->assertEquals($fieldConfigId, $this->configProvider->getId(DemoEntity::ENTITY_NAME, 'testField', 'string'));
$entityConfigIdWithOtherScope = new EntityConfigId('otherScope', DemoEntity::ENTITY_NAME);
$this->assertEquals($this->entityConfig, $this->configProvider->getConfigById($entityConfigIdWithOtherScope));
}
/**
* @param mixed $entity
* @param string $entityClass
* @param bool $show
* @return bool
*/
public function isEntityAuditable($entity, $entityClass, $show)
{
if (!is_object($entity) || $show) {
return $show;
}
$classEmpty = empty($entityClass);
if ($classEmpty && $entity instanceof EntityConfigModel) {
$className = $entity->getClassName();
} elseif ($classEmpty) {
$className = ClassUtils::getClass($entity);
} else {
$className = str_replace('_', '\\', $entityClass);
}
return $this->configProvider->hasConfig($className) && $this->configProvider->getConfig($className)->is('auditable');
}
/**
* @param string $activityClassName
* @param string $activityAssociationName
*
* @return bool
*/
protected function isActivityAssociationEnabled($activityClassName, $activityAssociationName)
{
if (!$this->extendConfigProvider->hasConfig($activityClassName, $activityAssociationName)) {
return false;
}
return ExtendHelper::isFieldAccessible($this->extendConfigProvider->getConfig($activityClassName, $activityAssociationName));
}
/**
* Check if given class field is deleted
*
* @param string $className FQCN
* @param string $fieldName
*
* @return bool
*/
protected function isDeletedField($className, $fieldName)
{
if ($this->extendConfigProvider->hasConfig($className, $fieldName)) {
return $this->extendConfigProvider->getConfig($className, $fieldName)->is('is_deleted');
}
return false;
}
/**
* Loads metadata for the given security type and save them in cache
*
* @param $securityType
*/
protected function loadMetadata($securityType)
{
$data = array();
$securityConfigs = $this->securityConfigProvider->getConfigs();
foreach ($securityConfigs as $securityConfig) {
$className = $securityConfig->getId()->getClassName();
if ($securityConfig->get('type') === $securityType && $this->extendConfigProvider->getConfig($className)->in('state', [ExtendScope::STATE_ACTIVE, ExtendScope::STATE_UPDATE])) {
$label = '';
if ($this->entityConfigProvider->hasConfig($className)) {
$label = $this->entityConfigProvider->getConfig($className)->get('label');
}
$permissions = $securityConfig->get('permissions');
if (!$permissions || $permissions == 'All') {
$permissions = array();
} else {
$permissions = explode(';', $permissions);
}
$data[$className] = new EntitySecurityMetadata($securityType, $className, $securityConfig->get('group_name'), $label, $permissions);
}
}
if ($this->cache) {
$this->cache->save($securityType, $data);
}
$this->localCache[$securityType] = $data;
}
/**
* @param object $entity
* @param int $pageType
* @return bool
*/
protected function isAllowedOnPage($entity, $pageType)
{
if (!$this->configProvider->hasConfig($entity)) {
return false;
}
$config = $this->configProvider->getConfig($entity);
if (!$config->has(ActivityScope::SHOW_ON_PAGE)) {
return false;
}
$configValue = $config->get(ActivityScope::SHOW_ON_PAGE);
if (!defined($configValue)) {
throw new \InvalidArgumentException(sprintf('Constant %s is not defined', $configValue));
}
$configValue = constant($configValue);
return $configValue !== ActivityScope::NONE_PAGE && ($configValue & $pageType) === $pageType;
}
/**
* Gets a relation type
*
* @param string $className
* @param string $fieldName
* @return string
*/
protected function getRelationType($className, $fieldName)
{
if ($this->entityConfigProvider->hasConfig($className, $fieldName)) {
return $this->entityConfigProvider->getConfig($className, $fieldName)->getId()->getFieldType();
}
return '';
}
/**
* @param object $object
* @param bool $withMultiValue
*
* @return array
*/
protected function getApplicableRelations($object, $withMultiValue = false)
{
$result = [];
$className = ClassUtils::getClass($object);
if (!$this->extendConfigProvider->hasConfig($className)) {
return $result;
}
$extendConfig = $this->extendConfigProvider->getConfig($className);
$relations = $extendConfig->get('relation');
if (empty($relations)) {
return $result;
}
$targetEntities = $this->getTargetEntities();
foreach ($relations as $relation) {
if (empty($relation['owner'])) {
continue;
}
/** @var FieldConfigId $fieldId */
$fieldId = $relation['field_id'];
$isApplicableRelationType = $fieldId->getFieldType() === 'manyToOne' || $withMultiValue && $fieldId->getFieldType() === 'manyToMany';
if (!$isApplicableRelationType) {
continue;
}
$relatedEntityClass = $relation['target_entity'];
if (!in_array($relatedEntityClass, $targetEntities)) {
continue;
}
if (!isset($result[$relatedEntityClass])) {
$result[$relatedEntityClass] = [];
}
$result[$relatedEntityClass][] = $fieldId->getFieldName();
}
return $result;
}
/**
* Get ACL sql conditions and join statements to check shared records
*
* @param string $entityName
* @param string $entityAlias
* @param mixed $permissions
*
* @return array
*/
public function getAclShareData($entityName, $entityAlias, $permissions = BasicPermissionMap::PERMISSION_VIEW)
{
if ($permissions !== BasicPermissionMap::PERMISSION_VIEW) {
return null;
}
$aclClass = $this->getObjectManager()->getRepository('OroSecurityBundle:AclClass')->findOneBy(['classType' => $entityName]);
if (!$aclClass) {
return null;
}
$shareConfig = null;
if ($this->configProvider->hasConfig($entityName)) {
$shareConfig = $this->configProvider->getConfig($entityName)->get('share_scopes');
}
if (!$shareConfig) {
return null;
}
$aclSIds = $this->getSecurityIdentityIds((array) $shareConfig);
if (empty($aclSIds)) {
return null;
}
$observer = new OneShotIsGrantedObserver();
$this->aclVoter->addOneShotIsGrantedObserver($observer);
$isGranted = $this->getSecurityContext()->isGranted($permissions, 'entity:' . $entityName);
if (!$isGranted || !in_array($observer->getAccessLevel(), $this->shareAccessLevels)) {
return null;
}
$shareCondition = ['existsSubselect' => ['select' => 1, 'from' => ['schemaName' => self::ACL_ENTRIES_SCHEMA_NAME, 'alias' => self::ACL_ENTRIES_ALIAS], 'where' => $this->getShareSubselectWhereConditions($entityAlias, $aclSIds, $aclClass)], 'not' => false];
//Add query components for OutputSqlWalker
$queryComponents[self::ACL_ENTRIES_ALIAS] = ['metadata' => $this->getObjectManager()->getClassMetadata(self::ACL_ENTRIES_SCHEMA_NAME), 'parent' => null, 'relation' => null, 'map' => null, 'nestingLevel' => null, 'token' => null];
return [$shareCondition, $queryComponents];
}
/**
* @param string $entityClass
*
* @return array
*/
protected function getEntityVariableGetters($entityClass)
{
$entityClass = ClassUtils::getRealClass($entityClass);
if (!$this->emailConfigProvider->hasConfig($entityClass)) {
return [];
}
$result = [];
$reflClass = new \ReflectionClass($entityClass);
$fieldConfigs = $this->emailConfigProvider->getConfigs($entityClass);
foreach ($fieldConfigs as $fieldConfig) {
if (!$fieldConfig->is('available_in_template')) {
continue;
}
/** @var FieldConfigId $fieldId */
$fieldId = $fieldConfig->getId();
list($varName, $getter) = $this->getFieldAccessInfo($reflClass, $fieldId->getFieldName());
if (!$varName) {
continue;
}
$resultGetter = $getter;
$formatters = $this->formatterManager->guessFormatters($fieldId);
if ($formatters && count($formatters)) {
$resultGetter = array_merge(['property_path' => $getter], $formatters);
}
$result[$varName] = $resultGetter;
}
return $result;
}
/**
* @param string $entity
* @return bool
*/
protected function isShowWorkflowStep($entity)
{
if ($this->configProvider->hasConfig($entity)) {
return $this->configProvider->getConfig($entity)->is('show_step_in_grid');
}
return false;
}
/**
* Check organization. If user try to access entity what was created in organization this user do not have access -
* deny access
*
* @param int $result
* @return int
*/
protected function checkOrganizationContext($result)
{
$object = $this->object;
$token = $this->securityToken;
if ($token instanceof OrganizationContextTokenInterface && $result === self::ACCESS_GRANTED && $this->extension instanceof EntityAclExtension && is_object($object) && !$object instanceof ObjectIdentity) {
$className = ClassUtils::getClass($object);
if ($this->configProvider->hasConfig($className)) {
$config = $this->configProvider->getConfig($className);
$accessLevel = $this->extension->getAccessLevel($this->triggeredMask);
// we need to check organization in case if Access level is not system,
// or then access level and owner type of test object is User or Business Unit (in this owner types we
// do not allow to use System access level)
// (do not allow to manipulate records from another organization)
if ($accessLevel < AccessLevel::SYSTEM_LEVEL || $accessLevel === AccessLevel::SYSTEM_LEVEL && in_array($config->get('owner_type'), ['USER', 'BUSINESS_UNIT'])) {
if ($config->has('organization_field_name')) {
$accessor = PropertyAccess::createPropertyAccessor();
/** @var Organization $objectOrganization */
$objectOrganization = $accessor->getValue($object, $config->get('organization_field_name'));
if ($objectOrganization && $objectOrganization->getId() !== $token->getOrganizationContext()->getId()) {
$result = self::ACCESS_DENIED;
}
}
}
}
}
return $result;
}
/**
* Makes sure metadata for dictionary entities were loaded
*/
protected function ensureDictionariesInitialized()
{
if (null === $this->dictionaries) {
$this->dictionaries = [];
$configs = $this->groupingConfigProvider->getConfigs();
foreach ($configs as $config) {
$groups = $config->get('groups');
if (!empty($groups) && in_array(GroupingScope::GROUP_DICTIONARY, $groups)) {
$className = $config->getId()->getClassName();
$metadata = $this->getManagerForClass($className)->getClassMetadata($className);
$fieldNames = null;
if ($this->dictionaryConfigProvider->hasConfig($className)) {
$fieldNames = $this->dictionaryConfigProvider->getConfig($className)->get('virtual_fields');
}
if (null === $fieldNames) {
$fieldNames = array_filter($metadata->getFieldNames(), function ($fieldName) use(&$metadata) {
return !$metadata->isIdentifier($fieldName);
});
}
$fields = [];
foreach ($fieldNames as $fieldName) {
$fields[$fieldName] = $metadata->getTypeOfField($fieldName);
}
$this->dictionaries[$className] = $fields;
}
}
}
}
