vendor/knplabs/knp-components/src/Knp/Component/Pager/Event/Subscriber/Sortable/ArraySubscriber.php line 43

  1. <?php
  3. namespace Knp\Component\Pager\Event\Subscriber\Sortable;
  5. use Knp\Component\Pager\Event\ItemsEvent;
  6. use Knp\Component\Pager\PaginatorInterface;
  7. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use Symfony\Component\PropertyAccess\Exception\UnexpectedTypeException;
  10. use Symfony\Component\PropertyAccess\PropertyAccess;
  11. use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
  13. class ArraySubscriber implements EventSubscriberInterface
  14. {
  15.     /**
  16.      * @var string the field used to sort current object array list
  17.      */
  18.     private string $currentSortingField;
  20.     /**
  21.      * @var string the sorting direction
  22.      */
  23.     private string $sortDirection;
  25.     private ?PropertyAccessorInterface $propertyAccessor;
  27.     private Request $request;
  29.     public function __construct(Request $request = null, PropertyAccessorInterface $accessor = null)
  30.     {
  31.         if (!$accessor && class_exists(PropertyAccess::class)) {
  32.             $accessor = PropertyAccess::createPropertyAccessorBuilder()->enableMagicCall()->getPropertyAccessor();
  33.         }
  35.         $this->propertyAccessor = $accessor;
  36.         // check needed because $request must be nullable, being the second parameter (with the first one nullable)
  37.         if (null === $request) {
  38.             throw new \InvalidArgumentException('Request must be initialized.');
  39.         }
  40.         $this->request = $request;
  41.     }
  43.     public function items(ItemsEvent $event): void
  44.     {
  45.         // Check if the result has already been sorted by an other sort subscriber
  46.         $customPaginationParameters = $event->getCustomPaginationParameters();
  47.         if (!empty($customPaginationParameters['sorted']) ) {
  48.             return;
  49.         }
  50.         $sortField = $event->options[PaginatorInterface::SORT_FIELD_PARAMETER_NAME];
  51.         if (!is_array($event->target) || null === $sortField || !$this->request->query->has($sortField)) {
  52.             return;
  53.         }
  55.         $event->setCustomPaginationParameter('sorted', true);
  57.         if (isset($event->options[PaginatorInterface::SORT_FIELD_ALLOW_LIST]) && !in_array($this->request->query->get($sortField), $event->options[PaginatorInterface::SORT_FIELD_ALLOW_LIST])) {
  58.             throw new \UnexpectedValueException("Cannot sort by: [{$this->request->query->get($sortField)}] this field is not in allow list.");
  59.         }
  61.         $sortFunction = $event->options['sortFunction'] ?? [$this, 'proxySortFunction'];
  62.         $sortField = $this->request->query->get($sortField);
  64.         // compatibility layer
  65.         if ($sortField[0] === '.') {
  66.             $sortField = substr($sortField, 1);
  67.         }
  69.         call_user_func_array($sortFunction, [
  70.             &$event->target,
  71.             $sortField,
  72.             $this->getSortDirection($event->options),
  73.         ]);
  74.     }
  76.     private function getSortDirection(array $options): string
  77.     {
  78.         if (!$this->request->query->has($options[PaginatorInterface::SORT_DIRECTION_PARAMETER_NAME])) {
  79.             return 'desc';
  80.         }
  81.         $direction = $this->request->query->get($options[PaginatorInterface::SORT_DIRECTION_PARAMETER_NAME]);
  82.         if (strtolower($direction) === 'asc') {
  83.             return 'asc';
  84.         }
  86.         return 'desc';
  87.     }
  89.     private function proxySortFunction(&$target, $sortField, $sortDirection): bool
  90.     {
  91.         $this->currentSortingField = $sortField;
  92.         $this->sortDirection = $sortDirection;
  94.         return usort($target, [$this, 'sortFunction']);
  95.     }
  97.     /**
  98.      * @param mixed $object1 first object to compare
  99.      * @param mixed $object2 second object to compare
  100.      *
  101.      * @return int
  102.      */
  103.     private function sortFunction($object1, $object2): int
  104.     {
  105.         if (null === $this->propertyAccessor) {
  106.             throw new \UnexpectedValueException('You need symfony/property-access component to use this sorting function');
  107.         }
  109.         if (!$this->propertyAccessor->isReadable($object1, $this->currentSortingField) || !$this->propertyAccessor->isReadable($object2, $this->currentSortingField)) {
  110.             return 0;
  111.         }
  113.         try {
  114.             $fieldValue1 = $this->propertyAccessor->getValue($object1, $this->currentSortingField);
  115.         } catch (UnexpectedTypeException $e) {
  116.             return -1 * $this->getSortCoefficient();
  117.         }
  119.         try {
  120.             $fieldValue2 = $this->propertyAccessor->getValue($object2, $this->currentSortingField);
  121.         } catch (UnexpectedTypeException $e) {
  122.             return 1 * $this->getSortCoefficient();
  123.         }
  125.         if (is_string($fieldValue1)) {
  126.             $fieldValue1 = mb_strtolower($fieldValue1);
  127.         }
  129.         if (is_string($fieldValue2)) {
  130.             $fieldValue2 = mb_strtolower($fieldValue2);
  131.         }
  133.         if ($fieldValue1 === $fieldValue2) {
  134.             return 0;
  135.         }
  137.         return ($fieldValue1 > $fieldValue2 ? 1 : -1) * $this->getSortCoefficient();
  138.     }
  140.     private function getSortCoefficient(): int
  141.     {
  142.         return $this->sortDirection === 'asc' ? 1 : -1;
  143.     }
  145.     public static function getSubscribedEvents(): array
  146.     {
  147.         return [
  148.             'knp_pager.items' => ['items', 1],
  149.         ];
  150.     }
  151. }