PHP Oro\Component\DoctrineUtils\ORM QueryBuilderUtil::checkField Code Examples

                                                    /**
     * @param string|string[]|null $from
     */
    public function getSimpleSearchQuery(
        ?string $searchString,
        ?int $offset = 0,
        ?int $maxResults = 0,
        $from = null,
        ?int $page = 0
    ): Query {
        $query = $this->select();
        $criteria = $query->getCriteria();

        $nameField = Criteria::implodeFieldTypeName(Query::TYPE_TEXT, self::NAME_FIELD);
        QueryBuilderUtil::checkField($nameField);

        $query->addSelect($nameField . ' as name');
        $query->from($from ?: '*');

        $searchString = trim($searchString);
        if ($searchString) {
            $criteria->where(Criteria::expr()->contains(
                Criteria::implodeFieldTypeName(Query::TYPE_TEXT, self::TEXT_ALL_DATA_FIELD),
                $searchString
            ));
        }

        $criteria->setMaxResults($maxResults > 0 ? $maxResults : Query::INFINITY);
        if ($page > 0) {
            $offset = $maxResults * ($page - 1);
        }
        if ($offset > 0) {
            $criteria->setFirstResult($offset);
        }

        return $query;
    }
                                            

                                                    /**
     * @return array [DQL, parameters]
     */
    public static function getSubQueryExpressionWithParameters(
        OrmFilterDatasourceAdapter $ds,
        QueryBuilder $subQuery,
        string $fieldExpr,
        string $filterName
    ): array {
        QueryBuilderUtil::checkField($fieldExpr);
        $subQuery
            ->resetDQLPart('orderBy')
            ->resetDQLPart('groupBy')
            ->select($fieldExpr)
            ->andWhere(sprintf('%1$s = %1$s', $fieldExpr));

        self::processSubQueryExpressionGroupBy($ds, $subQuery, $fieldExpr);
        [$dql, $replacements] = self::createDqlWithReplacedAliases($ds, $subQuery, $filterName);
        [$fieldAlias, $field] = explode('.', $fieldExpr);
        $replacedFieldExpr = sprintf('%s.%s', $replacements[$fieldAlias], $field);
        $oldExpr = sprintf('%1$s = %1$s', $replacedFieldExpr);
        $newExpr = sprintf('%s = %s', $replacedFieldExpr, $fieldExpr);
        $dql = strtr($dql, [$oldExpr => $newExpr]);

        return [$dql, $subQuery->getParameters()];
    }
                                            

                                                    /**
     * @inheritdoc
     */
    protected function buildComparisonExpr(
        FilterDatasourceAdapterInterface $ds,
        $comparisonType,
        $fieldName,
        $parameterName
    ) {
        QueryBuilderUtil::checkField($fieldName);

        switch ($comparisonType) {
            case FilterUtility::TYPE_NOT_EMPTY:
                return $ds->expr()->isNotNull($fieldName);
            case FilterUtility::TYPE_EMPTY:
                return $ds->expr()->isNull($fieldName);
            default:
                return parent::buildComparisonExpr($ds, $comparisonType, $fieldName, $parameterName);
        }
    }
                                            

                                                    protected function addWhereClause(QueryBuilder $qb, string $filterType)
    {
        $extraWhereClauses = !$qb->getDQLPart('where')
            ? null :
            $this->getExtraWhereClauses($qb->getDQLPart('where')->getParts());

        $whereClauseParameters = $this->getExtraWhereParameters($qb->getParameters(), $extraWhereClauses);

        $usedDates = $this->getUsedDates(
            $filterType,
            'calendarDateTableForGrouping',
            'date',
            $this->get(self::JOINED_TABLE),
            $this->get(self::JOINED_COLUMN),
            $extraWhereClauses,
            $whereClauseParameters
        );

        if (!$usedDates) {
            return;
        }

        $dataFieldName = $this->getDataFieldName();
        $notNullableField = $this->get(self::NOT_NULLABLE_FIELD);
        QueryBuilderUtil::checkField($notNullableField);

        $qb->andWhere(
            $qb->expr()->orX(
                $qb->expr()->andX(
                    $qb->expr()->notIn(
                        sprintf(
                            "CONCAT(%s(%s), '-', %s(%s))",
                            $filterType,
                            $dataFieldName,
                            self::TYPE_YEAR,
                            $dataFieldName
                        ),
                        $usedDates
                    )
                ),
                $qb->expr()->andX(
                    $qb->expr()->in(
                        sprintf(
                            "CONCAT(%s(%s), '-', %s(%s))",
                            $filterType,
                            $dataFieldName,
                            self::TYPE_YEAR,
                            $dataFieldName
                        ),
                        $usedDates
                    ),
                    $qb->expr()->isNotNull($notNullableField)
                )
            )
        );
    }
                                            

                                                    private function getSelectAlias(string $postfix): string
    {
        $selectAlias = $this->get(self::COLUMN_NAME) . ucfirst($postfix);
        QueryBuilderUtil::checkField($selectAlias);

        return $selectAlias;
    }
                                            

                                                    /**
     * If grouping by Day or Month make sure Year order is in same direction and keep multisort.
     */
    public function applyOrderBy(OrmDatasource $datasource, String $sortKey, String $direction)
    {
        QueryBuilderUtil::checkField($sortKey);
        $direction = QueryBuilderUtil::getSortOrder($direction);

        $qb = $datasource->getQueryBuilder();
        $added = false;

        foreach ([self::TYPE_YEAR, self::TYPE_QUARTER, self::TYPE_MONTH, self::TYPE_DAY] as $groupBy) {
            $columnName = $this->getSelectAlias($groupBy);
            $groupingName = $this->getSelectClause($groupBy);

            /** @var Select $select */
            foreach ($qb->getDQLPart('select') as $select) {
                foreach ($select->getParts() as $part) {
                    if (\in_array($part, [$groupingName, sprintf('%s as %s', $groupingName, $columnName)], true)) {
                        $qb->addOrderBy($columnName, $direction);
                        $added = true;
                    }
                }
            }
        }

        if (!$added) {
            $qb->addOrderBy($sortKey, $direction);
        }
    }
                                            

                                                    /**
     * @inheritDoc
     */
    public function apply(FilterDatasourceAdapterInterface $ds, $data)
    {
        $data = $this->parseData($data);
        if (!$data) {
            return false;
        }

        /** @var OrmFilterDatasourceAdapter $ds */
        /** @var QueryBuilder $qb */
        $qb = $ds->getQueryBuilder();
        $columnName = $this->get(self::COLUMN_NAME);
        QueryBuilderUtil::checkField($columnName);

        switch ($data['value']) {
            case self::TYPE_DAY:
                $dayGroupingName = $this->addFilter(self::TYPE_DAY, $qb);
                $monthGroupingName = $this->addFilter(self::TYPE_MONTH, $qb);
                $yearGroupingName = $this->addFilter(self::TYPE_YEAR, $qb);

                $this->addSelect(
                    $qb,
                    [
                        $dayGroupingName,
                        $monthGroupingName,
                        $yearGroupingName,
                    ],
                    $columnName
                );

                break;
            case self::TYPE_MONTH:
                $monthGroupingName = $this->addFilter(self::TYPE_MONTH, $qb);
                $yearGroupingName = $this->addFilter(self::TYPE_YEAR, $qb);

                $this->addSelect(
                    $qb,
                    [
                        $monthGroupingName,
                        $yearGroupingName,
                    ],
                    $columnName
                );

                $this->addWhereClause($qb, self::TYPE_MONTH);
                break;
            case self::TYPE_QUARTER:
                $quarterGroupingName = $this->addFilter(self::TYPE_QUARTER, $qb);
                $yearGroupingName = $this->addFilter(self::TYPE_YEAR, $qb);

                $this->addSelect(
                    $qb,
                    [
                        $quarterGroupingName,
                        $yearGroupingName,
                    ],
                    $columnName
                );

                $this->addWhereClause($qb, self::TYPE_QUARTER);
                break;
            default:
                $yearGroupingName = $this->addFilter(self::TYPE_YEAR, $qb);

                $qb->addSelect(sprintf('%s as %s', $yearGroupingName, $columnName));

                $this->addWhereClause($qb, self::TYPE_YEAR);
                break;
        }

        $qb->addGroupBy($columnName);

        return true;
    }
                                            

                                                    /**
     * Validates the filter field name.
     */
    protected function validateFieldName()
    {
        QueryBuilderUtil::checkField($this->get(FilterUtility::DATA_NAME_KEY));
    }
                                            

                                                    private function getIdentifierField(ActionConfiguration $actionConfiguration): string
    {
        $identifier = $actionConfiguration->offsetGetOr('data_identifier');
        if (!$identifier) {
            throw new LogicException('Mass action must define identifier name');
        }
        QueryBuilderUtil::checkField($identifier);

        return $identifier;
    }
                                            

                                                    public function addDatePartsSelect(
        \DateTime $start,
        \DateTime $end,
        QueryBuilder $qb,
        string $entityField
    ) {
        QueryBuilderUtil::checkField($entityField);
        switch ($this->getFormatStrings($start, $end)['viewType']) {
            case 'year':
                $qb->addSelect(sprintf(
                    '%s as yearCreated',
                    $this->getEnforcedTimezoneFunction('YEAR', $entityField)
                ));
                $qb->addGroupBy('yearCreated');
                break;
            case 'month':
                $qb->addSelect(sprintf(
                    '%s as yearCreated',
                    $this->getEnforcedTimezoneFunction('YEAR', $entityField)
                ));
                $qb->addSelect(
                    sprintf(
                        '%s as monthCreated',
                        $this->getEnforcedTimezoneFunction('MONTH', $entityField)
                    )
                );
                $qb->addGroupBy('yearCreated');
                $qb->addGroupBy('monthCreated');
                break;
            case 'date':
                $qb->addSelect(sprintf(
                    '%s as yearCreated',
                    $this->getEnforcedTimezoneFunction('YEAR', $entityField)
                ));
                $qb->addSelect(sprintf(
                    '%s as weekCreated',
                    $this->getEnforcedTimezoneFunction('WEEK', $entityField)
                ));
                $qb->addGroupBy('yearCreated');
                $qb->addGroupBy('weekCreated');
                break;
            case 'day':
                $qb->addSelect(sprintf(
                    '%s as yearCreated',
                    $this->getEnforcedTimezoneFunction('YEAR', $entityField)
                ));
                $qb->addSelect(
                    sprintf(
                        '%s as monthCreated',
                        $this->getEnforcedTimezoneFunction('MONTH', $entityField)
                    )
                );
                $qb->addSelect(sprintf(
                    '%s as dayCreated',
                    $this->getEnforcedTimezoneFunction('DAY', $entityField)
                ));
                $qb->addGroupBy('yearCreated');
                $qb->addGroupBy('monthCreated');
                $qb->addGroupBy('dayCreated');
                break;
            case 'time':
                $qb->addSelect(sprintf(
                    '%s as dateCreated',
                    $this->getEnforcedTimezoneFunction('DATE', $entityField)
                ));
                $qb->addSelect(sprintf(
                    '%s as hourCreated',
                    $this->getEnforcedTimezoneFunction('HOUR', $entityField)
                ));
                $qb->addGroupBy('dateCreated');
                $qb->addGroupBy('hourCreated');
                break;
        }
    }