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