src/Wallabag/ApiBundle/Controller/EntryRestController.php

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