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] = false === $res ? false : true;
  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 = false === $res ? false : true;
  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         /** @var \Pagerfanta\Pagerfanta $pager */
 102         $pager = $this->getDoctrine()
 103             ->getRepository('WallabagCoreBundle:Entry')
 104             ->findEntries($this->getUser()->getId(), $isArchived, $isStarred, $sort, $order, $since, $tags);
 105
 106         $pager->setMaxPerPage($perPage);
 107         $pager->setCurrentPage($page);
 108
 109         $pagerfantaFactory = new PagerfantaFactory('page', 'perPage');
 110         $paginatedCollection = $pagerfantaFactory->createRepresentation(
 111             $pager,
 112             new Route(
 113                 'api_get_entries',
 114                 [
 115                     'archive' => $isArchived,
 116                     'starred' => $isStarred,
 117                     'sort' => $sort,
 118                     'order' => $order,
 119                     'page' => $page,
 120                     'perPage' => $perPage,
 121                     'tags' => $tags,
 122                     'since' => $since,
 123                 ],
 124                 UrlGeneratorInterface::ABSOLUTE_URL
 125             )
 126         );
 127
 128         $json = $this->get('serializer')->serialize($paginatedCollection, 'json');
 129
 130         return (new JsonResponse())->setJson($json);
 131     }
 132
 133     /**
 134      * Retrieve a single entry.
 135      *
 136      * @ApiDoc(
 137      *      requirements={
 138      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 139      *      }
 140      * )
 141      *
 142      * @return JsonResponse
 143      */
 144     public function getEntryAction(Entry $entry)
 145     {
 146         $this->validateAuthentication();
 147         $this->validateUserAccess($entry->getUser()->getId());
 148
 149         $json = $this->get('serializer')->serialize($entry, 'json');
 150
 151         return (new JsonResponse())->setJson($json);
 152     }
 153
 154     /**
 155      * Retrieve a single entry as a predefined format.
 156      *
 157      * @ApiDoc(
 158      *      requirements={
 159      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 160      *      }
 161      * )
 162      *
 163      * @return Response
 164      */
 165     public function getEntryExportAction(Entry $entry, Request $request)
 166     {
 167         $this->validateAuthentication();
 168         $this->validateUserAccess($entry->getUser()->getId());
 169
 170         return $this->get('wallabag_core.helper.entries_export')
 171             ->setEntries($entry)
 172             ->updateTitle('entry')
 173             ->exportAs($request->attributes->get('_format'));
 174     }
 175
 176     /**
 177      * Create an entry.
 178      *
 179      * @ApiDoc(
 180      *       parameters={
 181      *          {"name"="url", "dataType"="string", "required"=true, "format"="http://www.test.com/article.html", "description"="Url for the entry."},
 182      *          {"name"="title", "dataType"="string", "required"=false, "description"="Optional, we'll get the title from the page."},
 183      *          {"name"="tags", "dataType"="string", "required"=false, "format"="tag1,tag2,tag3", "description"="a comma-separated list of tags."},
 184      *          {"name"="starred", "dataType"="integer", "required"=false, "format"="1 or 0", "description"="entry already starred"},
 185      *          {"name"="archive", "dataType"="integer", "required"=false, "format"="1 or 0", "description"="entry already archived"},
 186      *       }
 187      * )
 188      *
 189      * @return JsonResponse
 190      */
 191     public function postEntriesAction(Request $request)
 192     {
 193         $this->validateAuthentication();
 194
 195         $url = $request->request->get('url');
 196         $title = $request->request->get('title');
 197         $isArchived = $request->request->get('archive');
 198         $isStarred = $request->request->get('starred');
 199
 200         $entry = $this->get('wallabag_core.entry_repository')->findByUrlAndUserId($url, $this->getUser()->getId());
 201
 202         if (false === $entry) {
 203             $entry = new Entry($this->getUser());
 204             try {
 205                 $entry = $this->get('wallabag_core.content_proxy')->updateEntry(
 206                     $entry,
 207                     $url
 208                 );
 209             } catch (\Exception $e) {
 210                 $this->get('logger')->error('Error while saving an entry', [
 211                     'exception' => $e,
 212                     'entry' => $entry,
 213                 ]);
 214                 $entry->setUrl($url);
 215             }
 216         }
 217
 218         if (!is_null($title)) {
 219             $entry->setTitle($title);
 220         }
 221
 222         $tags = $request->request->get('tags', '');
 223         if (!empty($tags)) {
 224             $this->get('wallabag_core.content_proxy')->assignTagsToEntry($entry, $tags);
 225         }
 226
 227         if (!is_null($isStarred)) {
 228             $entry->setStarred((bool) $isStarred);
 229         }
 230
 231         if (!is_null($isArchived)) {
 232             $entry->setArchived((bool) $isArchived);
 233         }
 234
 235         $em = $this->getDoctrine()->getManager();
 236         $em->persist($entry);
 237         $em->flush();
 238
 239         // entry saved, dispatch event about it!
 240         $this->get('event_dispatcher')->dispatch(EntrySavedEvent::NAME, new EntrySavedEvent($entry));
 241
 242         $json = $this->get('serializer')->serialize($entry, 'json');
 243
 244         return (new JsonResponse())->setJson($json);
 245     }
 246
 247     /**
 248      * Change several properties of an entry.
 249      *
 250      * @ApiDoc(
 251      *      requirements={
 252      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 253      *      },
 254      *      parameters={
 255      *          {"name"="title", "dataType"="string", "required"=false},
 256      *          {"name"="tags", "dataType"="string", "required"=false, "format"="tag1,tag2,tag3", "description"="a comma-separated list of tags."},
 257      *          {"name"="archive", "dataType"="integer", "required"=false, "format"="1 or 0", "description"="archived the entry."},
 258      *          {"name"="starred", "dataType"="integer", "required"=false, "format"="1 or 0", "description"="starred the entry."},
 259      *      }
 260      * )
 261      *
 262      * @return JsonResponse
 263      */
 264     public function patchEntriesAction(Entry $entry, Request $request)
 265     {
 266         $this->validateAuthentication();
 267         $this->validateUserAccess($entry->getUser()->getId());
 268
 269         $title = $request->request->get('title');
 270         $isArchived = $request->request->get('archive');
 271         $isStarred = $request->request->get('starred');
 272
 273         if (!is_null($title)) {
 274             $entry->setTitle($title);
 275         }
 276
 277         if (!is_null($isArchived)) {
 278             $entry->setArchived((bool) $isArchived);
 279         }
 280
 281         if (!is_null($isStarred)) {
 282             $entry->setStarred((bool) $isStarred);
 283         }
 284
 285         $tags = $request->request->get('tags', '');
 286         if (!empty($tags)) {
 287             $this->get('wallabag_core.content_proxy')->assignTagsToEntry($entry, $tags);
 288         }
 289
 290         $em = $this->getDoctrine()->getManager();
 291         $em->flush();
 292
 293         $json = $this->get('serializer')->serialize($entry, 'json');
 294
 295         return (new JsonResponse())->setJson($json);
 296     }
 297
 298     /**
 299      * Reload an entry.
 300      * 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).
 301      *
 302      * @ApiDoc(
 303      *      requirements={
 304      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 305      *      }
 306      * )
 307      *
 308      * @return JsonResponse
 309      */
 310     public function patchEntriesReloadAction(Entry $entry)
 311     {
 312         $this->validateAuthentication();
 313         $this->validateUserAccess($entry->getUser()->getId());
 314
 315         try {
 316             $entry = $this->get('wallabag_core.content_proxy')->updateEntry($entry, $entry->getUrl());
 317         } catch (\Exception $e) {
 318             $this->get('logger')->error('Error while saving an entry', [
 319                 'exception' => $e,
 320                 'entry' => $entry,
 321             ]);
 322
 323             return new JsonResponse([], 304);
 324         }
 325
 326         // if refreshing entry failed, don't save it
 327         if ($this->getParameter('wallabag_core.fetching_error_message') === $entry->getContent()) {
 328             return new JsonResponse([], 304);
 329         }
 330
 331         $em = $this->getDoctrine()->getManager();
 332         $em->persist($entry);
 333         $em->flush();
 334
 335         // entry saved, dispatch event about it!
 336         $this->get('event_dispatcher')->dispatch(EntrySavedEvent::NAME, new EntrySavedEvent($entry));
 337
 338         $json = $this->get('serializer')->serialize($entry, 'json');
 339
 340         return (new JsonResponse())->setJson($json);
 341     }
 342
 343     /**
 344      * Delete **permanently** an entry.
 345      *
 346      * @ApiDoc(
 347      *      requirements={
 348      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 349      *      }
 350      * )
 351      *
 352      * @return JsonResponse
 353      */
 354     public function deleteEntriesAction(Entry $entry)
 355     {
 356         $this->validateAuthentication();
 357         $this->validateUserAccess($entry->getUser()->getId());
 358
 359         $em = $this->getDoctrine()->getManager();
 360         $em->remove($entry);
 361         $em->flush();
 362
 363         // entry deleted, dispatch event about it!
 364         $this->get('event_dispatcher')->dispatch(EntryDeletedEvent::NAME, new EntryDeletedEvent($entry));
 365
 366         $json = $this->get('serializer')->serialize($entry, 'json');
 367
 368         return (new JsonResponse())->setJson($json);
 369     }
 370
 371     /**
 372      * Retrieve all tags for an entry.
 373      *
 374      * @ApiDoc(
 375      *      requirements={
 376      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 377      *      }
 378      * )
 379      *
 380      * @return JsonResponse
 381      */
 382     public function getEntriesTagsAction(Entry $entry)
 383     {
 384         $this->validateAuthentication();
 385         $this->validateUserAccess($entry->getUser()->getId());
 386
 387         $json = $this->get('serializer')->serialize($entry->getTags(), 'json');
 388
 389         return (new JsonResponse())->setJson($json);
 390     }
 391
 392     /**
 393      * Add one or more tags to an entry.
 394      *
 395      * @ApiDoc(
 396      *      requirements={
 397      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 398      *      },
 399      *      parameters={
 400      *          {"name"="tags", "dataType"="string", "required"=false, "format"="tag1,tag2,tag3", "description"="a comma-separated list of tags."},
 401      *       }
 402      * )
 403      *
 404      * @return JsonResponse
 405      */
 406     public function postEntriesTagsAction(Request $request, Entry $entry)
 407     {
 408         $this->validateAuthentication();
 409         $this->validateUserAccess($entry->getUser()->getId());
 410
 411         $tags = $request->request->get('tags', '');
 412         if (!empty($tags)) {
 413             $this->get('wallabag_core.content_proxy')->assignTagsToEntry($entry, $tags);
 414         }
 415
 416         $em = $this->getDoctrine()->getManager();
 417         $em->persist($entry);
 418         $em->flush();
 419
 420         $json = $this->get('serializer')->serialize($entry, 'json');
 421
 422         return (new JsonResponse())->setJson($json);
 423     }
 424
 425     /**
 426      * Permanently remove one tag for an entry.
 427      *
 428      * @ApiDoc(
 429      *      requirements={
 430      *          {"name"="tag", "dataType"="integer", "requirement"="\w+", "description"="The tag ID"},
 431      *          {"name"="entry", "dataType"="integer", "requirement"="\w+", "description"="The entry ID"}
 432      *      }
 433      * )
 434      *
 435      * @return JsonResponse
 436      */
 437     public function deleteEntriesTagsAction(Entry $entry, Tag $tag)
 438     {
 439         $this->validateAuthentication();
 440         $this->validateUserAccess($entry->getUser()->getId());
 441
 442         $entry->removeTag($tag);
 443         $em = $this->getDoctrine()->getManager();
 444         $em->persist($entry);
 445         $em->flush();
 446
 447         $json = $this->get('serializer')->serialize($entry, 'json');
 448
 449         return (new JsonResponse())->setJson($json);
 450     }
 451 }