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