src/Wallabag/CoreBundle/Controller/ConfigController.php

   1 <?php
   2
   3 namespace Wallabag\CoreBundle\Controller;
   4
   5 use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
   6 use Symfony\Bundle\FrameworkBundle\Controller\Controller;
   7 use Symfony\Component\HttpFoundation\JsonResponse;
   8 use Symfony\Component\HttpFoundation\RedirectResponse;
   9 use Symfony\Component\HttpFoundation\Request;
  10 use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
  11 use Wallabag\CoreBundle\Entity\Config;
  12 use Wallabag\CoreBundle\Entity\TaggingRule;
  13 use Wallabag\CoreBundle\Form\Type\ConfigType;
  14 use Wallabag\CoreBundle\Form\Type\ChangePasswordType;
  15 use Wallabag\CoreBundle\Form\Type\RssType;
  16 use Wallabag\CoreBundle\Form\Type\TaggingRuleType;
  17 use Wallabag\CoreBundle\Form\Type\UserInformationType;
  18 use Wallabag\CoreBundle\Tools\Utils;
  19
  20 class ConfigController extends Controller
  21 {
  22     /**
  23      * @param Request $request
  24      *
  25      * @Route("/config", name="config")
  26      */
  27     public function indexAction(Request $request)
  28     {
  29         $em = $this->getDoctrine()->getManager();
  30         $config = $this->getConfig();
  31         $userManager = $this->container->get('fos_user.user_manager');
  32         $user = $this->getUser();
  33
  34         // handle basic config detail (this form is defined as a service)
  35         $configForm = $this->createForm(ConfigType::class, $config, ['action' => $this->generateUrl('config')]);
  36         $configForm->handleRequest($request);
  37
  38         if ($configForm->isValid()) {
  39             $em->persist($config);
  40             $em->flush();
  41
  42             // switch active theme
  43             $activeTheme = $this->get('liip_theme.active_theme');
  44             $activeTheme->setName($config->getTheme());
  45
  46             $this->get('session')->getFlashBag()->add(
  47                 'notice',
  48                 'flashes.config.notice.config_saved'
  49             );
  50
  51             return $this->redirect($this->generateUrl('config'));
  52         }
  53
  54         // handle changing password
  55         $pwdForm = $this->createForm(ChangePasswordType::class, null, ['action' => $this->generateUrl('config').'#set4']);
  56         $pwdForm->handleRequest($request);
  57
  58         if ($pwdForm->isValid()) {
  59             if ($this->get('craue_config')->get('demo_mode_enabled') && $this->get('craue_config')->get('demo_mode_username') === $user->getUsername()) {
  60                 $message = 'flashes.config.notice.password_not_updated_demo';
  61             } else {
  62                 $message = 'flashes.config.notice.password_updated';
  63
  64                 $user->setPlainPassword($pwdForm->get('new_password')->getData());
  65                 $userManager->updateUser($user, true);
  66             }
  67
  68             $this->get('session')->getFlashBag()->add('notice', $message);
  69
  70             return $this->redirect($this->generateUrl('config').'#set4');
  71         }
  72
  73         // handle changing user information
  74         $userForm = $this->createForm(UserInformationType::class, $user, [
  75             'validation_groups' => ['Profile'],
  76             'action' => $this->generateUrl('config').'#set3',
  77         ]);
  78         $userForm->handleRequest($request);
  79
  80         if ($userForm->isValid()) {
  81             $userManager->updateUser($user, true);
  82
  83             $this->get('session')->getFlashBag()->add(
  84                 'notice',
  85                 'flashes.config.notice.user_updated'
  86             );
  87
  88             return $this->redirect($this->generateUrl('config').'#set3');
  89         }
  90
  91         // handle rss information
  92         $rssForm = $this->createForm(RssType::class, $config, ['action' => $this->generateUrl('config').'#set2']);
  93         $rssForm->handleRequest($request);
  94
  95         if ($rssForm->isValid()) {
  96             $em->persist($config);
  97             $em->flush();
  98
  99             $this->get('session')->getFlashBag()->add(
 100                 'notice',
 101                 'flashes.config.notice.rss_updated'
 102             );
 103
 104             return $this->redirect($this->generateUrl('config').'#set2');
 105         }
 106
 107         // handle tagging rule
 108         $taggingRule = new TaggingRule();
 109         $action = $this->generateUrl('config').'#set5';
 110
 111         if ($request->query->has('tagging-rule')) {
 112             $taggingRule = $this->getDoctrine()
 113                 ->getRepository('WallabagCoreBundle:TaggingRule')
 114                 ->find($request->query->get('tagging-rule'));
 115
 116             if ($this->getUser()->getId() !== $taggingRule->getConfig()->getUser()->getId()) {
 117                 return $this->redirect($action);
 118             }
 119
 120             $action = $this->generateUrl('config').'?tagging-rule='.$taggingRule->getId().'#set5';
 121         }
 122
 123         $newTaggingRule = $this->createForm(TaggingRuleType::class, $taggingRule, ['action' => $action]);
 124         $newTaggingRule->handleRequest($request);
 125
 126         if ($newTaggingRule->isValid()) {
 127             $taggingRule->setConfig($config);
 128             $em->persist($taggingRule);
 129             $em->flush();
 130
 131             $this->get('session')->getFlashBag()->add(
 132                 'notice',
 133                 'flashes.config.notice.tagging_rules_updated'
 134             );
 135
 136             return $this->redirect($this->generateUrl('config').'#set5');
 137         }
 138
 139         return $this->render('WallabagCoreBundle:Config:index.html.twig', [
 140             'form' => [
 141                 'config' => $configForm->createView(),
 142                 'rss' => $rssForm->createView(),
 143                 'pwd' => $pwdForm->createView(),
 144                 'user' => $userForm->createView(),
 145                 'new_tagging_rule' => $newTaggingRule->createView(),
 146             ],
 147             'rss' => [
 148                 'username' => $user->getUsername(),
 149                 'token' => $config->getRssToken(),
 150             ],
 151             'twofactor_auth' => $this->getParameter('twofactor_auth'),
 152             'wallabag_url' => $this->get('craue_config')->get('wallabag_url'),
 153             'enabled_users' => $this->getDoctrine()
 154                 ->getRepository('WallabagUserBundle:User')
 155                 ->getSumEnabledUsers(),
 156         ]);
 157     }
 158
 159     /**
 160      * @param Request $request
 161      *
 162      * @Route("/generate-token", name="generate_token")
 163      *
 164      * @return RedirectResponse|JsonResponse
 165      */
 166     public function generateTokenAction(Request $request)
 167     {
 168         $config = $this->getConfig();
 169         $config->setRssToken(Utils::generateToken());
 170
 171         $em = $this->getDoctrine()->getManager();
 172         $em->persist($config);
 173         $em->flush();
 174
 175         if ($request->isXmlHttpRequest()) {
 176             return new JsonResponse(['token' => $config->getRssToken()]);
 177         }
 178
 179         $this->get('session')->getFlashBag()->add(
 180             'notice',
 181             'flashes.config.notice.rss_token_updated'
 182         );
 183
 184         return $this->redirect($this->generateUrl('config').'#set2');
 185     }
 186
 187     /**
 188      * Deletes a tagging rule and redirect to the config homepage.
 189      *
 190      * @param TaggingRule $rule
 191      *
 192      * @Route("/tagging-rule/delete/{id}", requirements={"id" = "\d+"}, name="delete_tagging_rule")
 193      *
 194      * @return RedirectResponse
 195      */
 196     public function deleteTaggingRuleAction(TaggingRule $rule)
 197     {
 198         $this->validateRuleAction($rule);
 199
 200         $em = $this->getDoctrine()->getManager();
 201         $em->remove($rule);
 202         $em->flush();
 203
 204         $this->get('session')->getFlashBag()->add(
 205             'notice',
 206             'flashes.config.notice.tagging_rules_deleted'
 207         );
 208
 209         return $this->redirect($this->generateUrl('config').'#set5');
 210     }
 211
 212     /**
 213      * Edit a tagging rule.
 214      *
 215      * @param TaggingRule $rule
 216      *
 217      * @Route("/tagging-rule/edit/{id}", requirements={"id" = "\d+"}, name="edit_tagging_rule")
 218      *
 219      * @return RedirectResponse
 220      */
 221     public function editTaggingRuleAction(TaggingRule $rule)
 222     {
 223         $this->validateRuleAction($rule);
 224
 225         return $this->redirect($this->generateUrl('config').'?tagging-rule='.$rule->getId().'#set5');
 226     }
 227
 228     /**
 229      * Remove all annotations OR tags OR entries for the current user.
 230      *
 231      * @Route("/reset/{type}", requirements={"id" = "annotations|tags|entries"}, name="config_reset")
 232      *
 233      * @return RedirectResponse
 234      */
 235     public function resetAction($type)
 236     {
 237         switch ($type) {
 238             case 'annotations':
 239                 $this->getDoctrine()
 240                     ->getRepository('WallabagAnnotationBundle:Annotation')
 241                     ->removeAllByUserId($this->getUser()->getId());
 242                 break;
 243
 244             case 'tags':
 245                 $this->removeAllTagsByUserId($this->getUser()->getId());
 246                 break;
 247
 248             case 'entries':
 249                 // SQLite doesn't care about cascading remove, so we need to manually remove associated stuf
 250                 // otherwise they won't be removed ...
 251                 if ($this->get('doctrine')->getConnection()->getDriver() instanceof \Doctrine\DBAL\Driver\PDOSqlite\Driver) {
 252                     $this->getDoctrine()->getRepository('WallabagAnnotationBundle:Annotation')->removeAllByUserId($this->getUser()->getId());
 253                 }
 254
 255                 // manually remove tags to avoid orphan tag
 256                 $this->removeAllTagsByUserId($this->getUser()->getId());
 257
 258                 $this->getDoctrine()
 259                     ->getRepository('WallabagCoreBundle:Entry')
 260                     ->removeAllByUserId($this->getUser()->getId());
 261         }
 262
 263         $this->get('session')->getFlashBag()->add(
 264             'notice',
 265             'flashes.config.notice.'.$type.'_reset'
 266         );
 267
 268         return $this->redirect($this->generateUrl('config').'#set3');
 269     }
 270
 271     /**
 272      * Remove all tags for a given user and cleanup orphan tags.
 273      *
 274      * @param int $userId
 275      */
 276     private function removeAllTagsByUserId($userId)
 277     {
 278         $tags = $this->getDoctrine()->getRepository('WallabagCoreBundle:Tag')->findAllTags($userId);
 279
 280         if (empty($tags)) {
 281             return;
 282         }
 283
 284         $this->getDoctrine()
 285             ->getRepository('WallabagCoreBundle:Entry')
 286             ->removeTags($userId, $tags);
 287
 288         // cleanup orphan tags
 289         $em = $this->getDoctrine()->getManager();
 290
 291         foreach ($tags as $tag) {
 292             if (count($tag->getEntries()) === 0) {
 293                 $em->remove($tag);
 294             }
 295         }
 296
 297         $em->flush();
 298     }
 299
 300     /**
 301      * Validate that a rule can be edited/deleted by the current user.
 302      *
 303      * @param TaggingRule $rule
 304      */
 305     private function validateRuleAction(TaggingRule $rule)
 306     {
 307         if ($this->getUser()->getId() != $rule->getConfig()->getUser()->getId()) {
 308             throw $this->createAccessDeniedException('You can not access this tagging rule.');
 309         }
 310     }
 311
 312     /**
 313      * Retrieve config for the current user.
 314      * If no config were found, create a new one.
 315      *
 316      * @return Config
 317      */
 318     private function getConfig()
 319     {
 320         $config = $this->getDoctrine()
 321             ->getRepository('WallabagCoreBundle:Config')
 322             ->findOneByUser($this->getUser());
 323
 324         // should NEVER HAPPEN ...
 325         if (!$config) {
 326             $config = new Config($this->getUser());
 327         }
 328
 329         return $config;
 330     }
 331
 332     /**
 333      * Delete account for current user.
 334      *
 335      * @Route("/account/delete", name="delete_account")
 336      *
 337      * @param Request $request
 338      *
 339      * @throws AccessDeniedHttpException
 340      *
 341      * @return \Symfony\Component\HttpFoundation\RedirectResponse
 342      */
 343     public function deleteAccountAction(Request $request)
 344     {
 345         $enabledUsers = $this->getDoctrine()
 346             ->getRepository('WallabagUserBundle:User')
 347             ->getSumEnabledUsers();
 348
 349         if ($enabledUsers <= 1) {
 350             throw new AccessDeniedHttpException();
 351         }
 352
 353         $user = $this->getUser();
 354
 355         // logout current user
 356         $this->get('security.token_storage')->setToken(null);
 357         $request->getSession()->invalidate();
 358
 359         $em = $this->get('fos_user.user_manager');
 360         $em->deleteUser($user);
 361
 362         return $this->redirect($this->generateUrl('fos_user_security_login'));
 363     }
 364 }