TransactionsCollection.php

Go to the documentation of this file.

<?php
namespace Magento\Braintree\Model\Report;

use Magento\Braintree\Model\Adapter\BraintreeAdapterFactory;
use Magento\Braintree\Model\Report\Row\TransactionMap;
use Magento\Framework\Api\Search\SearchResultInterface;
use Magento\Framework\Api\SearchCriteriaInterface;
use Magento\Framework\Data\Collection;
use Magento\Framework\Data\Collection\EntityFactoryInterface;

class TransactionsCollection extends Collection implements SearchResultInterface
{
    const TRANSACTION_MAXIMUM_COUNT = 100;

    protected $_itemObjectClass = TransactionMap::class;

    private $filtersList = [];

    private $filterMapper;

    private $braintreeAdapterFactory;

    private $collection;

    public function __construct(
        EntityFactoryInterface $entityFactory,
        BraintreeAdapterFactory $braintreeAdapterFactory,
        FilterMapper $filterMapper
    ) {
        parent::__construct($entityFactory);
        $this->filterMapper = $filterMapper;
        $this->braintreeAdapterFactory = $braintreeAdapterFactory;
    }

    public function getItems()
    {
        if (!$this->fetchIdsCollection()) {
            return [];
        }

        $result = [];
        $counter = 0;
        $pageSize = $this->getPageSize();
        $skipCounter = ($this->_curPage - 1) * $pageSize;

        // To optimize the processing of large searches, data is retrieved from the server lazily.
        foreach ($this->collection as $item) {
            if ($skipCounter > 0) {
                $skipCounter --;
            } else {
                $entity = $this->_entityFactory->create($this->_itemObjectClass, ['transaction' => $item]);
                if ($entity) {
                    $result[] = $entity;

                    $counter ++;
                    if ($pageSize && $counter >= $pageSize) {
                        break;
                    }
                }
            }
        }

        return $result;
    }

    protected function fetchIdsCollection()
    {
        if (empty($this->filtersList)) {
            return null;
        }

        // Fetch all transaction IDs in order to filter
        if (empty($this->collection)) {
            $filters = $this->getFilters();
            $this->collection = $this->braintreeAdapterFactory->create()
                ->search($filters);
        }

        return $this->collection;
    }

    public function setItems(array $items = null)
    {
        return $this;
    }

    public function getAggregations()
    {
        return null;
    }

    public function setAggregations($aggregations)
    {
        return $this;
    }

    public function getSearchCriteria()
    {
        return null;
    }

    public function setSearchCriteria(SearchCriteriaInterface $searchCriteria)
    {
        return $this;
    }

    public function getTotalCount()
    {
        $collection = $this->fetchIdsCollection();
        return null === $collection ? 0 : $collection->maximumCount();
    }

    public function getPageSize()
    {
        $pageSize = parent::getPageSize();
        return $pageSize === null ? static::TRANSACTION_MAXIMUM_COUNT : $pageSize;
    }

    public function setTotalCount($totalCount)
    {
        return $this;
    }

    public function addFieldToFilter($field, $condition)
    {
        if (is_array($field)) {
            return $this;
        }

        if (!is_array($condition)) {
            $condition = ['eq' => $condition];
        }

        $this->addFilterToList($this->filterMapper->getFilter($field, $condition));

        return $this;
    }

    private function addFilterToList($filter)
    {
        if (null !== $filter) {
            $this->filtersList[] = $filter;
        }
    }

    private function getFilters()
    {
        return $this->filtersList;
    }
}