src/Wallabag/CoreBundle/Form/Type/EntryFilterType.php

   1 <?php
   2
   3 namespace Wallabag\CoreBundle\Form\Type;
   4
   5 use Doctrine\ORM\EntityRepository;
   6 use Lexik\Bundle\FormFilterBundle\Filter\Query\QueryInterface;
   7 use Lexik\Bundle\FormFilterBundle\Filter\Form\Type\NumberRangeFilterType;
   8 use Lexik\Bundle\FormFilterBundle\Filter\Form\Type\DateRangeFilterType;
   9 use Lexik\Bundle\FormFilterBundle\Filter\Form\Type\TextFilterType;
  10 use Lexik\Bundle\FormFilterBundle\Filter\Form\Type\CheckboxFilterType;
  11 use Lexik\Bundle\FormFilterBundle\Filter\Form\Type\ChoiceFilterType;
  12 use Symfony\Component\Form\AbstractType;
  13 use Symfony\Component\Form\FormBuilderInterface;
  14 use Symfony\Component\HttpFoundation\Response;
  15 use Symfony\Component\OptionsResolver\OptionsResolver;
  16 use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage;
  17
  18 class EntryFilterType extends AbstractType
  19 {
  20     private $user;
  21     private $repository;
  22
  23     /**
  24      * Repository & user are used to get a list of language entries for this user.
  25      *
  26      * @param EntityRepository $entryRepository
  27      * @param TokenStorage     $token
  28      */
  29     public function __construct(EntityRepository $entryRepository, TokenStorage $token)
  30     {
  31         $this->repository = $entryRepository;
  32         $this->user = $token->getToken()->getUser();
  33     }
  34
  35     public function buildForm(FormBuilderInterface $builder, array $options)
  36     {
  37         $builder
  38             ->add('readingTime', NumberRangeFilterType::class, [
  39                 'apply_filter' => function (QueryInterface $filterQuery, $field, $values) {
  40                     $lower = $values['value']['left_number'][0];
  41                     $upper = $values['value']['right_number'][0];
  42
  43                     $min = (int) ($lower * $this->user->getConfig()->getReadingSpeed());
  44                     $max = (int) ($upper * $this->user->getConfig()->getReadingSpeed());
  45
  46                     if (null === $lower && null === $upper) {
  47                         // no value? no filter
  48                         return;
  49                     } elseif (null === $lower && null !== $upper) {
  50                         // only lower value is defined: query all entries with reading LOWER THAN this value
  51                         $expression = $filterQuery->getExpr()->lte($field, $max);
  52                     } elseif (null !== $lower && null === $upper) {
  53                         // only upper value is defined: query all entries with reading GREATER THAN this value
  54                         $expression = $filterQuery->getExpr()->gte($field, $min);
  55                     } else {
  56                         // both value are defined, perform a between
  57                         $expression = $filterQuery->getExpr()->between($field, $min, $max);
  58                     }
  59
  60                     return $filterQuery->createCondition($expression);
  61                 },
  62                 'label' => 'entry.filters.reading_time.label',
  63             ])
  64             ->add('createdAt', DateRangeFilterType::class, [
  65                     'left_date_options' => [
  66                         'attr' => [
  67                             'placeholder' => 'dd/mm/yyyy',
  68                         ],
  69                         'format' => 'dd/MM/yyyy',
  70                         'widget' => 'single_text',
  71                     ],
  72                     'right_date_options' => [
  73                         'attr' => [
  74                             'placeholder' => 'dd/mm/yyyy',
  75                         ],
  76                         'format' => 'dd/MM/yyyy',
  77                         'widget' => 'single_text',
  78                     ],
  79                     'label' => 'entry.filters.created_at.label',
  80                 ]
  81             )
  82             ->add('domainName', TextFilterType::class, [
  83                 'apply_filter' => function (QueryInterface $filterQuery, $field, $values) {
  84                     $value = $values['value'];
  85                     if (strlen($value) <= 2 || empty($value)) {
  86                         return;
  87                     }
  88                     $expression = $filterQuery->getExpr()->like($field, $filterQuery->getExpr()->literal('%'.$value.'%'));
  89
  90                     return $filterQuery->createCondition($expression);
  91                 },
  92                 'label' => 'entry.filters.domain_label',
  93             ])
  94             ->add('httpStatus', TextFilterType::class, [
  95                 'apply_filter' => function (QueryInterface $filterQuery, $field, $values) {
  96                     $value = $values['value'];
  97                     if (false === array_key_exists($value, Response::$statusTexts)) {
  98                         return;
  99                     }
 100
 101                     $paramName = sprintf('%s', str_replace('.', '_', $field));
 102                     $expression = $filterQuery->getExpr()->eq($field, ':'.$paramName);
 103                     $parameters = array($paramName => $value);
 104
 105                     return $filterQuery->createCondition($expression, $parameters);
 106                 },
 107                 'label' => 'entry.filters.http_status_label',
 108             ])
 109             ->add('isArchived', CheckboxFilterType::class, [
 110                 'label' => 'entry.filters.archived_label',
 111             ])
 112             ->add('isStarred', CheckboxFilterType::class, [
 113                 'label' => 'entry.filters.starred_label',
 114             ])
 115             ->add('isUnread', CheckboxFilterType::class, [
 116                 'label' => 'entry.filters.unread_label',
 117                 'apply_filter' => function (QueryInterface $filterQuery, $field, $values) {
 118                     if (false === $values['value']) {
 119                         return;
 120                     }
 121
 122                     $expression = $filterQuery->getExpr()->eq('e.isArchived', 'false');
 123
 124                     return $filterQuery->createCondition($expression);
 125                 },
 126             ])
 127             ->add('previewPicture', CheckboxFilterType::class, [
 128                 'apply_filter' => function (QueryInterface $filterQuery, $field, $values) {
 129                     if (false === $values['value']) {
 130                         return;
 131                     }
 132
 133                     $expression = $filterQuery->getExpr()->isNotNull($field);
 134
 135                     return $filterQuery->createCondition($expression);
 136                 },
 137                 'label' => 'entry.filters.preview_picture_label',
 138             ])
 139             ->add('language', ChoiceFilterType::class, [
 140                 'choices' => array_flip($this->repository->findDistinctLanguageByUser($this->user->getId())),
 141                 'label' => 'entry.filters.language_label',
 142             ])
 143         ;
 144     }
 145
 146     public function getBlockPrefix()
 147     {
 148         return 'entry_filter';
 149     }
 150
 151     public function configureOptions(OptionsResolver $resolver)
 152     {
 153         $resolver->setDefaults([
 154             'csrf_protection' => false,
 155             'validation_groups' => ['filtering'],
 156         ]);
 157     }
 158 }