OroCRM\Bundle\SalesBundle\Entity\Repository\OpportunityRepository

Complexity

Total Complexity

66

Size/Duplication

Total Lines	718
Duplicated Lines	26.32 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	getOpportunitiesByStatus()	0	7	1
B	getGroupedOpportunitiesByStatusQB()	0	34	1
C	getOpportunitiesDataByStatus()	5	42	7
A	getForecastOfOpportunitiesData()	0	8	2
B	getForecastOfOpportunitiesCurrentData()	0	34	4
B	getForecastOfOpportunitiesOldData()	0	39	5
A	getHistoryOldValue()	0	13	4
A	isStatusOk()	0	10	2
A	isOwnerOk()	0	11	2
A	calculateOpportunityOldValue()	0	11	2
A	getOpportunitiesCount()	10	10	1
A	getNewOpportunitiesCount()	10	10	1
A	createOpportunitiesCountQb()	21	21	4
B	getTotalServicePipelineAmount()	0	30	4
B	getTotalServicePipelineAmountInProgress()	24	24	3
A	getWeightedPipelineAmount()	18	18	3
A	getOpenWeightedPipelineAmount()	21	21	2
A	getNewOpportunitiesAmount()	0	18	2
A	getWonOpportunitiesToDateCount()	19	19	2
A	getWonOpportunitiesToDateAmount()	19	19	2
A	setCreationPeriod()	10	10	3
A	setClosedPeriod()	10	10	3
A	getOpportunitiesCountGroupByLeadSource()	11	11	1
A	getOpportunitiesAmountGroupByLeadSource()	11	11	1
A	getOpportunitiesGroupByLeadSourceQueryBuilder()	0	19	2
A	getForecastQB()	0	15	2

<?php

namespace OroCRM\Bundle\SalesBundle\Entity\Repository;

use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\QueryBuilder;

use Oro\Bundle\DashboardBundle\Filter\DateFilterProcessor;
use Oro\Bundle\DataAuditBundle\Loggable\LoggableManager;
use Oro\Bundle\SecurityBundle\ORM\Walker\AclHelper;
use Oro\Bundle\EntityExtendBundle\Tools\ExtendHelper;
use Oro\Bundle\WorkflowBundle\Entity\WorkflowStep;
use Oro\Component\DoctrineUtils\ORM\QueryUtils;

use OroCRM\Bundle\SalesBundle\Entity\Opportunity;

/**
 * @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
 */
class OpportunityRepository extends EntityRepository
{
    const OPPORTUNITY_STATE_IN_PROGRESS      = 'In Progress';
    const OPPORTUNITY_STATE_IN_PROGRESS_CODE = 'in_progress';
    const OPPORTUNITY_STATUS_CLOSED_WON_CODE  = 'won';

    /**
     * @var WorkflowStep[]
     */
    protected $workflowStepsByName;

    /**
     * Get opportunities by state by current quarter
     *
     * @param           $aclHelper AclHelper
     * @param  array    $dateRange
     * @param  array    $states
     * @param int[]     $owners
     *
     * @param AclHelper $aclHelper
     * @param array     $dateRange
     * @param array     $states
     * @param int[]     $owners
     *
     * @return array
     */
    public function getOpportunitiesByStatus(AclHelper $aclHelper, $dateRange, $states, $owners = [])
    {
        $dateEnd   = $dateRange['end'];
        $dateStart = $dateRange['start'];

        return $this->getOpportunitiesDataByStatus($aclHelper, $dateStart, $dateEnd, $states, $owners);
    }

    /**
     * @param string $alias
     * @param string $orderBy
     * @param string $direction
     *
     * @return QueryBuilder
     *
     */
    public function getGroupedOpportunitiesByStatusQB(
        $alias,
        $orderBy = 'budget',
        $direction = 'DESC'
    ) {
        $statusClass = ExtendHelper::buildEnumValueClassName('opportunity_status');
        $repository  = $this->getEntityManager()->getRepository($statusClass);

        $qb = $repository->createQueryBuilder('s')
            ->select(
                's.name as label',
                sprintf('COUNT(%s.id) as quantity', $alias),
                // Use close revenue for calculating budget for opportunities with won statuses
                sprintf(
                    "SUM(
                        CASE WHEN s.id = 'won'
                            THEN
                                (CASE WHEN %s.closeRevenue IS NOT NULL THEN %s.closeRevenue ELSE 0 END)
                            ELSE
                                (CASE WHEN %s.budgetAmount IS NOT NULL THEN %s.budgetAmount ELSE 0 END)
                        END
                    ) as budget",
                    $alias,
                    $alias,
                    $alias,
                    $alias
                )
            )
            ->leftJoin('OroCRMSalesBundle:Opportunity', $alias, 'WITH', sprintf('%s.status = s', $alias))
            ->groupBy('s.name')
            ->orderBy($orderBy, $direction);

        return $qb;
    }

    /**
     * @param  AclHelper $aclHelper
     * @param            $dateStart
     * @param            $dateEnd
     * @param array      $states
     * @param int[]      $owners
     *
     * @return array
     */
    protected function getOpportunitiesDataByStatus(
        AclHelper $aclHelper,
        $dateStart = null,
        $dateEnd = null,
        $states = [],
        $owners = []
    ) {
        foreach ($states as $key => $name) {
            $resultData[$key] = [

$resultData was never initialized. Although not strictly required by PHP, it is generally a good practice to add $resultData = array(); before regardless.

                'name'   => $key,
                'label'  => $name,
                'budget' => 0,
            ];
        }

        // select opportunity data
        $qb = $this->createQueryBuilder('opportunity');
        $qb->select('IDENTITY(opportunity.status) as name, SUM(opportunity.budgetAmount) as budget')
            ->groupBy('opportunity.status');

        if ($dateStart && $dateEnd) {

This code seems to be duplicated across your project.

            $qb->where($qb->expr()->between('opportunity.createdAt', ':dateFrom', ':dateTo'))
                ->setParameter('dateFrom', $dateStart)
                ->setParameter('dateTo', $dateEnd);
        }

        if ($owners) {

The expression $owners of type integer[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            QueryUtils::applyOptimizedIn($qb, 'opportunity.owner', $owners);
        }

        $groupedData = $aclHelper->apply($qb)->getArrayResult();

        foreach ($groupedData as $statusData) {
            $status = $statusData['name'];
            $budget = (float)$statusData['budget'];
            if ($budget) {
                $resultData[$status]['budget'] = $budget;

The variable $resultData does not seem to be defined for all execution paths leading up to this point.

            }
        }

        return $resultData;
    }

    /**
     * @param array       $ownerIds
     * @param \DateTime    $date
     * @param AclHelper   $aclHelper
     *
     * @param string|null $start
     * @param string|null $end
     *
     * @return mixed
     */
    public function getForecastOfOpportunitiesData($ownerIds, $date, AclHelper $aclHelper, $start = null, $end = null)
    {
        if ($date === null) {
            return $this->getForecastOfOpportunitiesCurrentData($ownerIds, $aclHelper, $start, $end);
        }

        return $this->getForecastOfOpportunitiesOldData($ownerIds, $date, $aclHelper);
    }

    /**
     * @param array       $ownerIds
     * @param AclHelper   $aclHelper
     * @param string|null $start
     * @param string|null $end
     *
     * @return mixed
     */
    protected function getForecastOfOpportunitiesCurrentData(
        $ownerIds,
        AclHelper $aclHelper,
        $start = null,
        $end = null
    ) {
        $qb = $this->createQueryBuilder('opportunity');

        $select = "
            COUNT( opportunity.id ) as inProgressCount,
            SUM( opportunity.budgetAmount ) as budgetAmount,
            SUM( opportunity.budgetAmount * opportunity.probability ) as weightedForecast";
        $qb
            ->select($select)
            ->andWhere('opportunity.status NOT IN (:notCountedStatuses)')
            ->setParameter('notCountedStatuses', ['lost', 'won']);
        if (!empty($ownerIds)) {
            $qb->join('opportunity.owner', 'owner');
            QueryUtils::applyOptimizedIn($qb, 'owner.id', $ownerIds);
        }

        if ($start) {

The expression $start of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $qb
                ->andWhere('opportunity.closeDate >= :startDate')
                ->setParameter('startDate', $start);
        }
        if ($end) {

The expression $end of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $qb
                ->andWhere('opportunity.closeDate <= :endDate')
                ->setParameter('endDate', $end);
        }

        return $aclHelper->apply($qb)->getOneOrNullResult();
    }

    /**
     * @param array     $ownerIds
     * @param \DateTime $date
     * @param AclHelper $aclHelper
     *
     * @return mixed
     */
    protected function getForecastOfOpportunitiesOldData($ownerIds, $date, AclHelper $aclHelper)
    {
        //clone date for avoiding wrong date on printing with current locale
        $newDate = clone $date;
        $qb      = $this->createQueryBuilder('opportunity')
            ->where('opportunity.createdAt < :date')
            ->setParameter('date', $newDate);

        $opportunities = $aclHelper->apply($qb)->getResult();

        $result['inProgressCount']  = 0;

$result was never initialized. Although not strictly required by PHP, it is generally a good practice to add $result = array(); before regardless.

        $result['budgetAmount']     = 0;
        $result['weightedForecast'] = 0;

        $auditRepository = $this->getEntityManager()->getRepository('OroDataAuditBundle:Audit');
        /** @var Opportunity $opportunity */
        foreach ($opportunities as $opportunity) {
            $auditQb = $auditRepository->getLogEntriesQueryBuilder($opportunity);
            $auditQb->andWhere('a.action = :action')
                ->andWhere('a.loggedAt > :date')
                ->setParameter('action', LoggableManager::ACTION_UPDATE)
                ->setParameter('date', $newDate);
            $opportunityHistory = $aclHelper->apply($auditQb)->getResult();

            if ($oldProbability = $this->getHistoryOldValue($opportunityHistory, 'probability')) {
                $probability     = $oldProbability;
            } else {
                $probability     = $opportunity->getProbability();
            }

            if ($this->isOwnerOk($ownerIds, $opportunityHistory, $opportunity)
                && $this->isStatusOk($opportunityHistory, $opportunity)
            ) {
                $result = $this->calculateOpportunityOldValue($result, $opportunityHistory, $opportunity, $probability);
            }
        }

        return $result;
    }

    /**
     * @param mixed  $opportunityHistory
     * @param string $field
     *
     * @return mixed
     */
    protected function getHistoryOldValue($opportunityHistory, $field)
    {
        $result = null;

        $opportunityHistory = is_array($opportunityHistory) ? $opportunityHistory : [$opportunityHistory];
        foreach ($opportunityHistory as $item) {
            if ($item->getField($field)) {
                $result = $item->getField($field)->getOldValue();
            }
        }

        return $result;
    }

    /**
     * @param array       $opportunityHistory
     * @param Opportunity $opportunity
     *
     * @return bool
     */
    protected function isStatusOk($opportunityHistory, $opportunity)
    {
        if ($oldStatus = $this->getHistoryOldValue($opportunityHistory, 'status')) {
            $isStatusOk = $oldStatus === self::OPPORTUNITY_STATE_IN_PROGRESS;
        } else {
            $isStatusOk = $opportunity->getStatus()->getName() === self::OPPORTUNITY_STATE_IN_PROGRESS_CODE;
        }

        return $isStatusOk;
    }

    /**
     * @param array       $ownerIds
     * @param array       $opportunityHistory
     * @param Opportunity $opportunity
     *
     * @return bool
     */
    protected function isOwnerOk($ownerIds, $opportunityHistory, $opportunity)
    {
        $userRepository = $this->getEntityManager()->getRepository('OroUserBundle:User');
        if ($oldOwner = $this->getHistoryOldValue($opportunityHistory, 'owner')) {
            $isOwnerOk = in_array($userRepository->findOneByUsername($oldOwner)->getId(), $ownerIds);
        } else {
            $isOwnerOk = in_array($opportunity->getOwner()->getId(), $ownerIds);
        }

        return $isOwnerOk;
    }

    /**
     * @param array       $result
     * @param array       $opportunityHistory
     * @param Opportunity $opportunity
     * @param mixed       $probability
     *
     * @return array
     */
    protected function calculateOpportunityOldValue($result, $opportunityHistory, $opportunity, $probability)
    {
        ++$result['inProgressCount'];
        $oldBudgetAmount = $this->getHistoryOldValue($opportunityHistory, 'budgetAmount');

        $budget = $oldBudgetAmount !== null ? $oldBudgetAmount : $opportunity->getBudgetAmount();
        $result['budgetAmount'] += $budget;
        $result['weightedForecast'] += $budget * $probability;

        return $result;
    }

    /**
     * @param AclHelper $aclHelper
     * @param \DateTime  $start
     * @param \DateTime  $end
     * @param int[]     $owners
     *
     * @return int
     */
    public function getOpportunitiesCount(

This method seems to be duplicated in your project.

        AclHelper $aclHelper,
        \DateTime $start = null,
        \DateTime $end = null,
        $owners = []
    ) {
        $qb = $this->createOpportunitiesCountQb($start, $end, $owners);

        return $aclHelper->apply($qb)->getSingleScalarResult();
    }

    /**
     * @param AclHelper $aclHelper
     * @param \DateTime  $start
     * @param \DateTime  $end
     * @param int[]     $owners
     *
     * @return int
     */
    public function getNewOpportunitiesCount(

This method seems to be duplicated in your project.

        AclHelper $aclHelper,
        \DateTime $start = null,
        \DateTime $end = null,
        $owners = []
    ) {
        $qb = $this->createOpportunitiesCountQb($start, $end, $owners);

        return $aclHelper->apply($qb)->getSingleScalarResult();
    }

    /**
     * @param \DateTime $start
     * @param \DateTime $end
     * @param int[]    $owners
     *
     * @return QueryBuilder
     */
    public function createOpportunitiesCountQb(\DateTime $start = null, \DateTime $end = null, $owners = [])

This method seems to be duplicated in your project.

    {
        $qb = $this->createQueryBuilder('o');
        $qb->select('COUNT(o.id)');
        if ($start) {
            $qb
                ->andWhere('o.createdAt >= :start')
                ->setParameter('start', $start);
        }
        if ($end) {
            $qb
                ->andWhere('o.createdAt <= :end')
                ->setParameter('end', $end);
        }

        if ($owners) {

The expression $owners of type integer[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            QueryUtils::applyOptimizedIn($qb, 'o.owner', $owners);
        }

        return $qb;
    }

    /**
     * @param AclHelper $aclHelper
     * @param \DateTime  $start
     * @param \DateTime  $end
     * @param int[]     $owners
     *
     * @return double
     */
    public function getTotalServicePipelineAmount(
        AclHelper $aclHelper,
        \DateTime $start = null,
        \DateTime $end = null,
        $owners = []
    ) {
        $qb = $this->createQueryBuilder('o');

        $qb
            ->select('SUM(o.budgetAmount)')
            ->andWhere('o.closeDate IS NULL')
            ->andWhere('o.status = :status')
            ->setParameter('status', self::OPPORTUNITY_STATE_IN_PROGRESS_CODE);
        if ($start) {
            $qb
                ->andWhere('o.createdAt > :start')
                ->setParameter('start', $start);
        }
        if ($end) {
            $qb
                ->andWhere('o.createdAt < :end')
                ->setParameter('end', $end);
        }

        if ($owners) {

The expression $owners of type integer[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            QueryUtils::applyOptimizedIn($qb, 'o.owner', $owners);
        }

        return $aclHelper->apply($qb)->getSingleScalarResult();
    }

    /**
     * @param AclHelper $aclHelper
     * @param \DateTime  $start
     * @param \DateTime  $end
     *
     * @return double
     */
    public function getTotalServicePipelineAmountInProgress(

This method seems to be duplicated in your project.

        AclHelper $aclHelper,
        \DateTime $start = null,
        \DateTime $end = null
    ) {
        $qb = $this->createQueryBuilder('o');

        $qb
            ->select('SUM(o.budgetAmount)')
            ->andWhere('o.status = :status')
            ->setParameter('status', self::OPPORTUNITY_STATE_IN_PROGRESS_CODE);
        if ($start) {
            $qb
                ->andWhere('o.createdAt > :start')
                ->setParameter('start', $start);
        }
        if ($end) {
            $qb
                ->andWhere('o.createdAt < :end')
                ->setParameter('end', $end);
        }

        return $aclHelper->apply($qb)->getSingleScalarResult();
    }

    /**
     * @param AclHelper $aclHelper
     * @param \DateTime  $start
     * @param \DateTime  $end
     *
     * @return double
     */
    public function getWeightedPipelineAmount(AclHelper $aclHelper, \DateTime $start = null, \DateTime $end = null)

This method seems to be duplicated in your project.

    {
        $qb = $this->createQueryBuilder('o');

        $qb->select('SUM(o.budgetAmount * o.probability)');
        if ($start) {
            $qb
                ->andWhere('o.createdAt > :start')
                ->setParameter('start', $start);
        }
        if ($end) {
            $qb
                ->andWhere('o.createdAt < :end')
                ->setParameter('end', $end);
        }

        return $aclHelper->apply($qb)->getSingleScalarResult();
    }

    /**
     * @param AclHelper $aclHelper
     * @param \DateTime  $start
     * @param \DateTime  $end
     * @param int[]     $owners
     *
     * @return double
     */
    public function getOpenWeightedPipelineAmount(

This method seems to be duplicated in your project.

        AclHelper $aclHelper,
        \DateTime $start = null,
        \DateTime $end = null,
        $owners = []
    ) {
        $qb = $this->createQueryBuilder('o');

        $qb
            ->select('SUM(o.budgetAmount * o.probability)')
            ->andWhere('o.status = :status')
            ->setParameter('status', self::OPPORTUNITY_STATE_IN_PROGRESS_CODE);

        $this->setCreationPeriod($qb, $start, $end);

        if ($owners) {

The expression $owners of type integer[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            QueryUtils::applyOptimizedIn($qb, 'o.owner', $owners);
        }

        return $aclHelper->apply($qb)->getSingleScalarResult();
    }

    /**
     * @param AclHelper $aclHelper
     * @param \DateTime  $start
     * @param \DateTime  $end
     * @param int[]     $owners
     *
     * @return double
     */
    public function getNewOpportunitiesAmount(
        AclHelper $aclHelper,
        \DateTime $start = null,
        \DateTime $end = null,
        $owners = []
    ) {
        $qb = $this
            ->createQueryBuilder('o')
            ->select('SUM(o.budgetAmount)');

        $this->setCreationPeriod($qb, $start, $end);

        if ($owners) {

The expression $owners of type integer[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            QueryUtils::applyOptimizedIn($qb, 'o.owner', $owners);
        }

        return $aclHelper->apply($qb)->getSingleScalarResult();
    }

    /**
     * @param AclHelper $aclHelper
     * @param \DateTime  $start
     * @param \DateTime  $end
     * @param int[]     $owners
     *
     * @return int
     */
    public function getWonOpportunitiesToDateCount(

This method seems to be duplicated in your project.

        AclHelper $aclHelper,
        \DateTime $start = null,
        \DateTime $end = null,
        $owners = []
    ) {
        $qb = $this->createQueryBuilder('o');
        $qb->select('COUNT(o.id)')
            ->andWhere('o.status = :status')
            ->setParameter('status', self::OPPORTUNITY_STATUS_CLOSED_WON_CODE);

        $this->setClosedPeriod($qb, $start, $end);

        if ($owners) {

The expression $owners of type integer[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            QueryUtils::applyOptimizedIn($qb, 'o.owner', $owners);
        }

        return $aclHelper->apply($qb)->getSingleScalarResult();
    }

    /**
     * @param AclHelper $aclHelper
     * @param \DateTime  $start
     * @param \DateTime  $end
     * @param int[]     $owners
     *
     * @return double
     */
    public function getWonOpportunitiesToDateAmount(

This method seems to be duplicated in your project.

        AclHelper $aclHelper,
        \DateTime $start = null,
        \DateTime $end = null,
        $owners = []
    ) {
        $qb = $this->createQueryBuilder('o');
        $qb->select('SUM(o.closeRevenue)')
            ->andWhere('o.status = :status')
            ->setParameter('status', self::OPPORTUNITY_STATUS_CLOSED_WON_CODE);

        $this->setClosedPeriod($qb, $start, $end);

        if ($owners) {

The expression $owners of type integer[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            QueryUtils::applyOptimizedIn($qb, 'o.owner', $owners);
        }

        return $aclHelper->apply($qb)->getSingleScalarResult();
    }

    /**
     * @param QueryBuilder $qb
     * @param \DateTime|null $start
     * @param \DateTime|null $end
     */
    protected function setCreationPeriod(QueryBuilder $qb, \DateTime $start = null, \DateTime $end = null)

This method seems to be duplicated in your project.

    {
        if ($start) {
            $qb->andWhere('o.createdAt >= :dateStart')->setParameter('dateStart', $start);
        }

        if ($end) {
            $qb->andWhere('o.createdAt <= :dateEnd')->setParameter('dateEnd', $end);
        }
    }

    /**
     * @param QueryBuilder $qb
     * @param \DateTime|null $start
     * @param \DateTime|null $end
     */
    protected function setClosedPeriod(QueryBuilder $qb, \DateTime $start = null, \DateTime $end = null)

This method seems to be duplicated in your project.

    {
        if ($start) {
            $qb->andWhere('o.closedAt >= :dateStart')->setParameter('dateStart', $start);
        }

        if ($end) {
            $qb->andWhere('o.closedAt <= :dateEnd')->setParameter('dateEnd', $end);
        }
    }

    /**
     * Returns count of opportunities grouped by lead source
     *
     * @param AclHelper $aclHelper
     * @param DateFilterProcessor $dateFilterProcessor
     * @param array $dateRange
     * @param array $owners
     *
     * @return array [value, source]
     */
    public function getOpportunitiesCountGroupByLeadSource(

This method seems to be duplicated in your project.

        AclHelper $aclHelper,
        DateFilterProcessor $dateFilterProcessor,
        array $dateRange = [],
        array $owners = []
    ) {
        $qb = $this->getOpportunitiesGroupByLeadSourceQueryBuilder($dateFilterProcessor, $dateRange, $owners);
        $qb->addSelect('count(o.id) as value');

        return $aclHelper->apply($qb)->getArrayResult();
    }

    /**
     * Returns budget amount of opportunities grouped by lead source
     *
     * @param AclHelper $aclHelper
     * @param DateFilterProcessor $dateFilterProcessor
     * @param array $dateRange
     * @param array $owners
     *
     * @return array [value, source]
     */
    public function getOpportunitiesAmountGroupByLeadSource(

This method seems to be duplicated in your project.

        AclHelper $aclHelper,
        DateFilterProcessor $dateFilterProcessor,
        array $dateRange = [],
        array $owners = []
    ) {
        $qb = $this->getOpportunitiesGroupByLeadSourceQueryBuilder($dateFilterProcessor, $dateRange, $owners);
        $qb->addSelect("SUM(CASE WHEN o.status = 'won' THEN o.closeRevenue ELSE o.budgetAmount END) as value");

        return $aclHelper->apply($qb)->getArrayResult();
    }

    /**
     * Returns opportunities QB grouped by lead source filtered by $dateRange and $owners
     *
     * @param DateFilterProcessor $dateFilterProcessor
     * @param array $dateRange
     * @param array $owners
     *
     * @return QueryBuilder
     */
    protected function getOpportunitiesGroupByLeadSourceQueryBuilder(
        DateFilterProcessor $dateFilterProcessor,
        array $dateRange = [],
        array $owners = []
    ) {
        $qb = $this->createQueryBuilder('o')
            ->select('s.id as source')
            ->leftJoin('o.lead', 'l')
            ->leftJoin('l.source', 's')
            ->groupBy('source');

        $dateFilterProcessor->process($qb, $dateRange, 'o.createdAt');

        if ($owners) {

The expression $owners of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            QueryUtils::applyOptimizedIn($qb, 'o.owner', $owners);
        }

        return $qb;
    }

    /**
     * @param string $alias
     * @param array  $excludedStatuses
     *
     * @return QueryBuilder
     */
    public function getForecastQB($alias = 'o', array $excludedStatuses = ['lost', 'won'])
    {
        $qb     = $this->createQueryBuilder($alias);
        $qb->select([
            sprintf('COUNT(%s.id) as inProgressCount', $alias),
            sprintf('SUM(%s.budgetAmount) as budgetAmount', $alias),
            sprintf('SUM(%s.budgetAmount * %s.probability) as weightedForecast', $alias, $alias)
        ]);

        if ($excludedStatuses) {

The expression $excludedStatuses of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $qb->andWhere($qb->expr()->notIn(sprintf('%s.status', $alias), $excludedStatuses));
        }

        return $qb;
    }
}