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