src/Wallabag/ApiBundle/Controller/WallabagRestController.php

   1 <?php
   2
   3 namespace Wallabag\ApiBundle\Controller;
   4
   5 use FOS\RestBundle\Controller\FOSRestController;
   6 use Hateoas\Configuration\Route as HateoasRoute;
   7 use Hateoas\Representation\Factory\PagerfantaFactory;
   8 use Nelmio\ApiDocBundle\Annotation\ApiDoc;
   9 use Symfony\Component\HttpFoundation\Request;
  10 use Symfony\Component\HttpFoundation\JsonResponse;
  11 use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  12 use Symfony\Component\Security\Core\Exception\AccessDeniedException;
  13 use Wallabag\CoreBundle\Entity\Entry;
  14 use Wallabag\CoreBundle\Entity\Tag;
  15
  16 class WallabagRestController extends FOSRestController
  17 {
  18     private function validateAuthentication()
  19     {
  20         if (false === $this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  21             throw new AccessDeniedException();
  22         }
  23     }
  24
  25     /**
  26      * Check if an entry exist by url.
  27      *
  28      * @ApiDoc(
  29      *       parameters={
  30      *          {"name"="url", "dataType"="string", "required"=true, "format"="An url", "description"="Url to check if it exists"},
  31      *          {"name"="urls", "dataType"="string", "required"=false, "format"="An array of urls (?urls[]=http...&urls[]=http...)", "description"="Urls (as an array) to check if it exists"}
  32      *       }
  33      * )
  34      *
  35      * @return JsonResponse
  36      */
  37     public function getEntriesExistsAction(Request $request)
  38     {
  39         $this->validateAuthentication();
  40
  41         $urls = $request->query->get('urls', []);
  42
  43         // handle multiple urls first
  44         if (!empty($urls)) {
  45             $results = [];
  46             foreach ($urls as $url) {
  47                 $res = $this->getDoctrine()
  48                     ->getRepository('WallabagCoreBundle:Entry')
  49                     ->findByUrlAndUserId($url, $this->getUser()->getId());
  50
  51                 $results[$url] = false === $res ? false : true;
  52             }
  53
  54             $json = $this->get('serializer')->serialize($results, 'json');
  55
  56             return (new JsonResponse())->setJson($json);
  57         }
  58
  59         // let's see if it is a simple url?
  60         $url = $request->query->get('url', '');
  61
  62         if (empty($url)) {
  63             throw $this->createAccessDeniedException('URL is empty?, logged user id: '.$this->getUser()->getId());
  64         }
  65
  66         $res = $this->getDoctrine()
  67             ->getRepository('WallabagCoreBundle:Entry')
  68             ->findByUrlAndUserId($url, $this->getUser()->getId());
  69
  70         $exists = false === $res ? false : true;
  71
  72         $json = $this->get('serializer')->serialize(['exists' => $exists], 'json');
  73
  74         return (new JsonResponse())->setJson($json);
  75     }
  76
  77     /**
  78      * Retrieve all entries. It could be filtered by many options.
  79      *
  80      * @ApiDoc(
  81      *       parameters={
  82      *          {"name"="archive", "dataType"="integer", "required"=false, "format"="1 or 0, all entries by default", "description"="filter by archived status."},
  83      *          {"name"="starred", "dataType"="integer", "required"=false, "format"="1 or 0, all entries by default", "description"="filter by starred status."},
  84      *          {"name"="sort", "dataType"="string", "required"=false, "format"="'created' or 'updated', default 'created'", "description"="sort entries by date."},
  85      *          {"name"="order", "dataType"="string", "required"=false, "format"="'asc' or 'desc', default 'desc'", "description"="order of sort."},
  86      *          {"name"="page", "dataType"="integer", "required"=false, "format"="default '1'", "description"="what page you want."},
  87      *          {"name"="perPage", "dataType"="integer", "required"=false, "format"="default'30'", "description"="results per page."},
  88      *          {"name"="tags", "dataType"="string", "required"=false, "format"="api,rest", "description"="a list of tags url encoded. Will returns entries that matches ALL tags."},
  89      *          {"name"="since", "dataType"="integer", "required"=false, "format"="default '0'", "description"="The timestamp since when you want entries updated."},
  90      *       }
  91      * )
  92      *
  93      * @return JsonResponse
  94      */
  95     public function getEntriesAction(Request $request)
  96     {
  97         $this->validateAuthentication();
  98
  99         $isArchived = (null === $request->query->get('archive')) ? null : (bool) $request->query->get('archive');
 100         $isStarred = (null === $request->query->get('starred')) ? null : (bool) $request->query->get('starred');
 101         $sort = $request->query->get('sort', 'created');
 102         $order = $request->query->get('order', 'desc');
 103         $page = (int) $request->query->get('page', 1);
 104         $perPage = (int) $request->query->get('perPage', 30);
 105         $tags = $request->query->get('tags', '');
 106         $since = $request->query->get('since', 0);
 107
 108         $pager = $this->getDoctrine()
 109             ->getRepository('WallabagCoreBundle:Entry')
 110             ->findEntries($this->getUser()->getId(), $isArchived, $isStarred, $sort, $order, $since, $tags);
 111
 112         $pager->setCurrentPage($page);
 113         $pager->setMaxPerPage($perPage);
 114
 115         $pagerfantaFactory = new PagerfantaFactory('page', 'perPage');
 116         $paginatedCollection = $pagerfantaFactory->createRepresentation(
 117             $pager,
 118             new HateoasRoute(
 119                 'api_get_entries',
 120                 [
 121                     'archive' => $isArchived,
 122                     'starred' => $isStarred,
 123                     'sort' => $sort,
 124                     'order' => $order,
 125                     'page' => $page,
 126                     'perPage' => $perPage,
 127                     'tags' => $tags,
 128                     'since' => $since,
 129                 ],
 130                 UrlGeneratorInterface::ABSOLUTE_URL
 131             )
 132         );
 133
 134         $json = $this->get('serializer')->serialize($paginatedCollection, 'json');
 135
 136         return (new JsonResponse())->setJson($json);
 137     }
 138
 139     /**
 140      * Retrieve a single entry.
 141      *
 142      * @ApiDoc(
 143      *      requirements={
 144      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 145      *      }
 146      * )
 147      *
 148      * @return JsonResponse
 149      */
 150     public function getEntryAction(Entry $entry)
 151     {
 152         $this->validateAuthentication();
 153         $this->validateUserAccess($entry->getUser()->getId());
 154
 155         $json = $this->get('serializer')->serialize($entry, 'json');
 156
 157         return (new JsonResponse())->setJson($json);
 158     }
 159
 160     /**
 161      * Retrieve a single entry as a predefined format.
 162      *
 163      * @ApiDoc(
 164      *      requirements={
 165      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 166      *      }
 167      * )
 168      *
 169      * @return Response
 170      */
 171     public function getEntryExportAction(Entry $entry, Request $request)
 172     {
 173         $this->validateAuthentication();
 174         $this->validateUserAccess($entry->getUser()->getId());
 175
 176         return $this->get('wallabag_core.helper.entries_export')
 177             ->setEntries($entry)
 178             ->updateTitle('entry')
 179             ->exportAs($request->attributes->get('_format'));
 180     }
 181
 182     /**
 183      * Create an entry.
 184      *
 185      * @ApiDoc(
 186      *       parameters={
 187      *          {"name"="url", "dataType"="string", "required"=true, "format"="http://www.test.com/article.html", "description"="Url for the entry."},
 188      *          {"name"="title", "dataType"="string", "required"=false, "description"="Optional, we'll get the title from the page."},
 189      *          {"name"="tags", "dataType"="string", "required"=false, "format"="tag1,tag2,tag3", "description"="a comma-separated list of tags."},
 190      *          {"name"="starred", "dataType"="integer", "required"=false, "format"="1 or 0", "description"="entry already starred"},
 191      *          {"name"="archive", "dataType"="integer", "required"=false, "format"="1 or 0", "description"="entry already archived"},
 192      *       }
 193      * )
 194      *
 195      * @return JsonResponse
 196      */
 197     public function postEntriesAction(Request $request)
 198     {
 199         $this->validateAuthentication();
 200
 201         $url = $request->request->get('url');
 202         $title = $request->request->get('title');
 203         $isArchived = $request->request->get('archive');
 204         $isStarred = $request->request->get('starred');
 205
 206         $entry = $this->get('wallabag_core.entry_repository')->findByUrlAndUserId($url, $this->getUser()->getId());
 207
 208         if (false === $entry) {
 209             $entry = $this->get('wallabag_core.content_proxy')->updateEntry(
 210                 new Entry($this->getUser()),
 211                 $url
 212             );
 213         }
 214
 215         if (!is_null($title)) {
 216             $entry->setTitle($title);
 217         }
 218
 219         $tags = $request->request->get('tags', '');
 220         if (!empty($tags)) {
 221             $this->get('wallabag_core.content_proxy')->assignTagsToEntry($entry, $tags);
 222         }
 223
 224         if (!is_null($isStarred)) {
 225             $entry->setStarred((bool) $isStarred);
 226         }
 227
 228         if (!is_null($isArchived)) {
 229             $entry->setArchived((bool) $isArchived);
 230         }
 231
 232         $em = $this->getDoctrine()->getManager();
 233         $em->persist($entry);
 234
 235         $em->flush();
 236
 237         $json = $this->get('serializer')->serialize($entry, 'json');
 238
 239         return (new JsonResponse())->setJson($json);
 240     }
 241
 242     /**
 243      * Change several properties of an entry.
 244      *
 245      * @ApiDoc(
 246      *      requirements={
 247      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 248      *      },
 249      *      parameters={
 250      *          {"name"="title", "dataType"="string", "required"=false},
 251      *          {"name"="tags", "dataType"="string", "required"=false, "format"="tag1,tag2,tag3", "description"="a comma-separated list of tags."},
 252      *          {"name"="archive", "dataType"="integer", "required"=false, "format"="1 or 0", "description"="archived the entry."},
 253      *          {"name"="starred", "dataType"="integer", "required"=false, "format"="1 or 0", "description"="starred the entry."},
 254      *      }
 255      * )
 256      *
 257      * @return JsonResponse
 258      */
 259     public function patchEntriesAction(Entry $entry, Request $request)
 260     {
 261         $this->validateAuthentication();
 262         $this->validateUserAccess($entry->getUser()->getId());
 263
 264         $title = $request->request->get('title');
 265         $isArchived = $request->request->get('archive');
 266         $isStarred = $request->request->get('starred');
 267
 268         if (!is_null($title)) {
 269             $entry->setTitle($title);
 270         }
 271
 272         if (!is_null($isArchived)) {
 273             $entry->setArchived((bool) $isArchived);
 274         }
 275
 276         if (!is_null($isStarred)) {
 277             $entry->setStarred((bool) $isStarred);
 278         }
 279
 280         $tags = $request->request->get('tags', '');
 281         if (!empty($tags)) {
 282             $this->get('wallabag_core.content_proxy')->assignTagsToEntry($entry, $tags);
 283         }
 284
 285         $em = $this->getDoctrine()->getManager();
 286         $em->flush();
 287
 288         $json = $this->get('serializer')->serialize($entry, 'json');
 289
 290         return (new JsonResponse())->setJson($json);
 291     }
 292
 293     /**
 294      * Delete **permanently** an entry.
 295      *
 296      * @ApiDoc(
 297      *      requirements={
 298      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 299      *      }
 300      * )
 301      *
 302      * @return JsonResponse
 303      */
 304     public function deleteEntriesAction(Entry $entry)
 305     {
 306         $this->validateAuthentication();
 307         $this->validateUserAccess($entry->getUser()->getId());
 308
 309         $em = $this->getDoctrine()->getManager();
 310         $em->remove($entry);
 311         $em->flush();
 312
 313         $json = $this->get('serializer')->serialize($entry, 'json');
 314
 315         return (new JsonResponse())->setJson($json);
 316     }
 317
 318     /**
 319      * Retrieve all tags for an entry.
 320      *
 321      * @ApiDoc(
 322      *      requirements={
 323      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 324      *      }
 325      * )
 326      *
 327      * @return JsonResponse
 328      */
 329     public function getEntriesTagsAction(Entry $entry)
 330     {
 331         $this->validateAuthentication();
 332         $this->validateUserAccess($entry->getUser()->getId());
 333
 334         $json = $this->get('serializer')->serialize($entry->getTags(), 'json');
 335
 336         return (new JsonResponse())->setJson($json);
 337     }
 338
 339     /**
 340      * Add one or more tags to an entry.
 341      *
 342      * @ApiDoc(
 343      *      requirements={
 344      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 345      *      },
 346      *      parameters={
 347      *          {"name"="tags", "dataType"="string", "required"=false, "format"="tag1,tag2,tag3", "description"="a comma-separated list of tags."},
 348      *       }
 349      * )
 350      *
 351      * @return JsonResponse
 352      */
 353     public function postEntriesTagsAction(Request $request, Entry $entry)
 354     {
 355         $this->validateAuthentication();
 356         $this->validateUserAccess($entry->getUser()->getId());
 357
 358         $tags = $request->request->get('tags', '');
 359         if (!empty($tags)) {
 360             $this->get('wallabag_core.content_proxy')->assignTagsToEntry($entry, $tags);
 361         }
 362
 363         $em = $this->getDoctrine()->getManager();
 364         $em->persist($entry);
 365         $em->flush();
 366
 367         $json = $this->get('serializer')->serialize($entry, 'json');
 368
 369         return (new JsonResponse())->setJson($json);
 370     }
 371
 372     /**
 373      * Permanently remove one tag for an entry.
 374      *
 375      * @ApiDoc(
 376      *      requirements={
 377      *          {"name"="tag", "dataType"="integer", "requirement"="\w+", "description"="The tag ID"},
 378      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 379      *      }
 380      * )
 381      *
 382      * @return JsonResponse
 383      */
 384     public function deleteEntriesTagsAction(Entry $entry, Tag $tag)
 385     {
 386         $this->validateAuthentication();
 387         $this->validateUserAccess($entry->getUser()->getId());
 388
 389         $entry->removeTag($tag);
 390         $em = $this->getDoctrine()->getManager();
 391         $em->persist($entry);
 392         $em->flush();
 393
 394         $json = $this->get('serializer')->serialize($entry, 'json');
 395
 396         return (new JsonResponse())->setJson($json);
 397     }
 398
 399     /**
 400      * Retrieve all tags.
 401      *
 402      * @ApiDoc()
 403      *
 404      * @return JsonResponse
 405      */
 406     public function getTagsAction()
 407     {
 408         $this->validateAuthentication();
 409
 410         $tags = $this->getDoctrine()
 411             ->getRepository('WallabagCoreBundle:Tag')
 412             ->findAllTags($this->getUser()->getId());
 413
 414         $json = $this->get('serializer')->serialize($tags, 'json');
 415
 416         return (new JsonResponse())->setJson($json);
 417     }
 418
 419     /**
 420      * Permanently remove one tag from **every** entry.
 421      *
 422      * @ApiDoc(
 423      *      requirements={
 424      *          {"name"="tag", "dataType"="string", "required"=true, "requirement"="\w+", "description"="Tag as a string"}
 425      *      }
 426      * )
 427      *
 428      * @return JsonResponse
 429      */
 430     public function deleteTagLabelAction(Request $request)
 431     {
 432         $this->validateAuthentication();
 433         $label = $request->request->get('tag', '');
 434
 435         $tag = $this->getDoctrine()->getRepository('WallabagCoreBundle:Tag')->findOneByLabel($label);
 436
 437         if (empty($tag)) {
 438             throw $this->createNotFoundException('Tag not found');
 439         }
 440
 441         $this->getDoctrine()
 442             ->getRepository('WallabagCoreBundle:Entry')
 443             ->removeTag($this->getUser()->getId(), $tag);
 444
 445         $this->cleanOrphanTag($tag);
 446
 447         $json = $this->get('serializer')->serialize($tag, 'json');
 448
 449         return (new JsonResponse())->setJson($json);
 450     }
 451
 452     /**
 453      * Permanently remove some tags from **every** entry.
 454      *
 455      * @ApiDoc(
 456      *      requirements={
 457      *          {"name"="tags", "dataType"="string", "required"=true, "format"="tag1,tag2", "description"="Tags as strings (comma splitted)"}
 458      *      }
 459      * )
 460      *
 461      * @return JsonResponse
 462      */
 463     public function deleteTagsLabelAction(Request $request)
 464     {
 465         $this->validateAuthentication();
 466
 467         $tagsLabels = $request->request->get('tags', '');
 468
 469         $tags = [];
 470
 471         foreach (explode(',', $tagsLabels) as $tagLabel) {
 472             $tagEntity = $this->getDoctrine()->getRepository('WallabagCoreBundle:Tag')->findOneByLabel($tagLabel);
 473
 474             if (!empty($tagEntity)) {
 475                 $tags[] = $tagEntity;
 476             }
 477         }
 478
 479         if (empty($tags)) {
 480             throw $this->createNotFoundException('Tags not found');
 481         }
 482
 483         $this->getDoctrine()
 484             ->getRepository('WallabagCoreBundle:Entry')
 485             ->removeTags($this->getUser()->getId(), $tags);
 486
 487         $this->cleanOrphanTag($tags);
 488
 489         $json = $this->get('serializer')->serialize($tags, 'json');
 490
 491         return (new JsonResponse())->setJson($json);
 492     }
 493
 494     /**
 495      * Permanently remove one tag from **every** entry.
 496      *
 497      * @ApiDoc(
 498      *      requirements={
 499      *          {"name"="tag", "dataType"="integer", "requirement"="\w+", "description"="The tag"}
 500      *      }
 501      * )
 502      *
 503      * @return JsonResponse
 504      */
 505     public function deleteTagAction(Tag $tag)
 506     {
 507         $this->validateAuthentication();
 508
 509         $this->getDoctrine()
 510             ->getRepository('WallabagCoreBundle:Entry')
 511             ->removeTag($this->getUser()->getId(), $tag);
 512
 513         $this->cleanOrphanTag($tag);
 514
 515         $json = $this->get('serializer')->serialize($tag, 'json');
 516
 517         return (new JsonResponse())->setJson($json);
 518     }
 519
 520     /**
 521      * Retrieve version number.
 522      *
 523      * @ApiDoc()
 524      *
 525      * @return JsonResponse
 526      */
 527     public function getVersionAction()
 528     {
 529         $version = $this->container->getParameter('wallabag_core.version');
 530
 531         $json = $this->get('serializer')->serialize($version, 'json');
 532
 533         return (new JsonResponse())->setJson($json);
 534     }
 535
 536     /**
 537      * Remove orphan tag in case no entries are associated to it.
 538      *
 539      * @param Tag|array $tags
 540      */
 541     private function cleanOrphanTag($tags)
 542     {
 543         if (!is_array($tags)) {
 544             $tags = [$tags];
 545         }
 546
 547         $em = $this->getDoctrine()->getManager();
 548
 549         foreach ($tags as $tag) {
 550             if (count($tag->getEntries()) === 0) {
 551                 $em->remove($tag);
 552             }
 553         }
 554
 555         $em->flush();
 556     }
 557
 558     /**
 559      * Validate that the first id is equal to the second one.
 560      * If not, throw exception. It means a user try to access information from an other user.
 561      *
 562      * @param int $requestUserId User id from the requested source
 563      */
 564     private function validateUserAccess($requestUserId)
 565     {
 566         $user = $this->get('security.token_storage')->getToken()->getUser();
 567         if ($requestUserId != $user->getId()) {
 568             throw $this->createAccessDeniedException('Access forbidden. Entry user id: '.$requestUserId.', logged user id: '.$user->getId());
 569         }
 570     }
 571 }