Exemplo n.º 1
0
 /**
  * @param AbstractQueryDesigner         $value
  * @param GroupingConstraint|Constraint $constraint
  */
 public function validate($value, Constraint $constraint)
 {
     $definition = json_decode($value->getDefinition(), true);
     if (empty($definition['columns'])) {
         return;
     }
     $columns = $definition['columns'];
     $aggregateColumns = array_filter($columns, function (array $column) {
         return !empty($column['func']);
     });
     if (empty($aggregateColumns)) {
         return;
     }
     $groupingColumns = [];
     if (!empty($definition['grouping_columns'])) {
         $groupingColumns = $definition['grouping_columns'];
     }
     $groupingColumnNames = ArrayUtil::arrayColumn($groupingColumns, 'name');
     $columnNames = ArrayUtil::arrayColumn($columns, 'name');
     $columnNamesToCheck = array_diff($columnNames, ArrayUtil::arrayColumn($aggregateColumns, 'name'));
     $columnsToGroup = array_diff($columnNamesToCheck, $groupingColumnNames);
     if (empty($columnsToGroup)) {
         return;
     }
     $columnLabels = [];
     foreach ($columns as $column) {
         if (in_array($column['name'], $columnsToGroup)) {
             $columnLabels[] = $column['label'];
         }
     }
     $this->context->addViolation($this->translator->trans($constraint->message, ['%columns%' => implode(', ', $columnLabels)]));
 }
Exemplo n.º 2
0
 /**
  * @param GridQueryDesignerInterface|AbstractQueryDesigner $value
  * @param QueryConstraint|Constraint                       $constraint
  */
 public function validate($value, Constraint $constraint)
 {
     if (!$value instanceof GridQueryDesignerInterface) {
         return;
     }
     $gridPrefix = $value->getGridPrefix();
     $builder = $this->getBuilder($gridPrefix);
     $builder->setGridName($gridPrefix);
     $builder->setSource($value);
     $message = $this->translator->trans($constraint->message);
     try {
         $dataGrid = $this->gridBuilder->build($builder->getConfiguration(), new ParameterBag());
         $dataSource = $dataGrid->getDatasource();
         if ($dataSource instanceof OrmDatasource) {
             $qb = $dataSource->getQueryBuilder();
             $qb->setMaxResults(1);
         }
         $dataSource->getResults();
     } catch (DBALException $e) {
         $this->context->addViolation($this->isDebug ? $e->getMessage() : $message);
     } catch (ORMException $e) {
         $this->context->addViolation($this->isDebug ? $e->getMessage() : $message);
     } catch (InvalidConfigurationException $e) {
         $this->context->addViolation($this->isDebug ? $e->getMessage() : $message);
     }
 }
 /**
  * @param AbstractQueryDesigner $abstractQueryDesigner
  * @param object $entity
  * @param string $type
  *
  * @return string[]
  */
 public function getQueryContactInformationFields(AbstractQueryDesigner $abstractQueryDesigner, $entity, $type)
 {
     $contactInformationFields = $this->contactInformationFieldHelper->getEntityContactInformationColumns(ClassUtils::getRealClass($entity));
     if (empty($contactInformationFields)) {
         return [];
     }
     $definitionColumns = [];
     $definition = $abstractQueryDesigner->getDefinition();
     if ($definition) {
         $definition = json_decode($definition, JSON_OBJECT_AS_ARRAY);
         if (!empty($definition['columns'])) {
             $definitionColumns = array_map(function (array $columnDefinition) {
                 return $columnDefinition['name'];
             }, $definition['columns']);
         }
     }
     $typedFields = array_keys(array_filter($contactInformationFields, function ($contactInformationField) use($type) {
         return $contactInformationField === $type;
     }));
     if (!empty($definitionColumns)) {
         $typedFields = array_intersect($typedFields, $definitionColumns);
     }
     $propertyAccessor = PropertyAccess::createPropertyAccessor();
     return array_map(function ($typedField) use($propertyAccessor, $entity) {
         return (string) $propertyAccessor->getValue($entity, $typedField);
     }, $typedFields);
 }
Exemplo n.º 4
0
 public function testProvider()
 {
     $this->assertFalse($this->provider->getEntityName());
     $entityName = 'Acme\\Entity\\Test\\Entity';
     $this->entity->expects($this->once())->method('getEntity')->will($this->returnValue($entityName));
     $this->provider->setCurrentItem($this->entity);
     $this->assertEquals($entityName, $this->provider->getEntityName());
 }
 /**
  * Converts a query from the query designer format to a target format
  *
  * @param AbstractQueryDesigner $source
  * @throws InvalidConfigurationException
  */
 protected function doConvert(AbstractQueryDesigner $source)
 {
     $this->entity = $source->getEntity();
     $this->definition = json_decode($source->getDefinition(), true);
     if (!isset($this->definition['columns'])) {
         throw new InvalidConfigurationException('The "columns" definition does not exist.');
     }
     if (empty($this->definition['columns'])) {
         throw new InvalidConfigurationException('The "columns" definition must not be empty.');
     }
     $this->tableAliases = [];
     $this->columnAliases = [];
     $this->buildQuery();
     $this->tableAliases = null;
     $this->columnAliases = null;
 }
 /**
  * @param AbstractQueryDesigner $queryDesigner
  * @param string|null $type
  *
  * @return array
  */
 public function getQueryTypedFields(AbstractQueryDesigner $queryDesigner, $type = null)
 {
     $entityClass = $queryDesigner->getEntity();
     $typedFields = $this->getEntityTypedFields($entityClass, $type);
     $definitionColumns = [];
     $definition = $queryDesigner->getDefinition();
     if ($definition) {
         $definition = json_decode($definition, JSON_OBJECT_AS_ARRAY);
         if (!empty($definition['columns'])) {
             $definitionColumns = array_map(function (array $columnDefinition) {
                 return $columnDefinition['name'];
             }, $definition['columns']);
         }
     }
     if (!empty($definitionColumns)) {
         $typedFields = array_intersect($typedFields, $definitionColumns);
     }
     return $typedFields;
 }
 /**
  * @param AbstractQueryDesigner $queryDesigner
  *
  * @return array
  */
 public function getQueryContactInformationColumns(AbstractQueryDesigner $queryDesigner)
 {
     $columns = array();
     // If definition is empty there is no one contact information field
     $definition = $queryDesigner->getDefinition();
     if (!$definition) {
         return $columns;
     }
     $definition = json_decode($definition, JSON_OBJECT_AS_ARRAY);
     if (empty($definition['columns'])) {
         return $columns;
     }
     $entity = $queryDesigner->getEntity();
     foreach ($definition['columns'] as $column) {
         $contactInformationType = $this->getContactInformationFieldType($entity, $column['name']);
         if (!empty($contactInformationType)) {
             $columns[$contactInformationType][] = $column;
         }
     }
     return $columns;
 }
Exemplo n.º 8
0
 /**
  * Process convert
  *
  * @param AbstractQueryDesigner $source
  *
  * @return \Doctrine\ORM\QueryBuilder
  */
 public function convert(AbstractQueryDesigner $source)
 {
     $this->qb = $this->doctrine->getManagerForClass($source->getEntity())->createQueryBuilder();
     $this->doConvert($source);
     return $this->qb;
 }
Exemplo n.º 9
0
 /**
  * @param AbstractQueryDesigner $entity
  */
 public function setCurrentItem(AbstractQueryDesigner $entity)
 {
     $this->entityName = $entity->getEntity();
 }
 /**
  * @param AbstractQueryDesigner $source
  */
 public function setSource(AbstractQueryDesigner $source)
 {
     $em = $this->doctrine->getManagerForClass($source->getEntity());
     $this->source = new DatagridSourceSegmentProxy($source, $em);
 }