src/Wallabag/ImportBundle/Import/PocketImport.php

   1 <?php
   2
   3 namespace Wallabag\ImportBundle\Import;
   4
   5 use Http\Client\Common\HttpMethodsClient;
   6 use Http\Client\Common\Plugin\ErrorPlugin;
   7 use Http\Client\Common\PluginClient;
   8 use Http\Client\HttpClient;
   9 use Http\Discovery\MessageFactoryDiscovery;
  10 use Http\Message\MessageFactory;
  11 use Http\Client\Exception\RequestException;
  12 use Wallabag\CoreBundle\Entity\Entry;
  13 use Psr\Http\Message\ResponseInterface;
  14
  15 class PocketImport extends AbstractImport
  16 {
  17     const NB_ELEMENTS = 5000;
  18     /**
  19      * @var HttpMethodsClient
  20      */
  21     private $client;
  22     private $accessToken;
  23
  24     /**
  25      * Only used for test purpose.
  26      *
  27      * @return string
  28      */
  29     public function getAccessToken()
  30     {
  31         return $this->accessToken;
  32     }
  33
  34     /**
  35      * {@inheritdoc}
  36      */
  37     public function getName()
  38     {
  39         return 'Pocket';
  40     }
  41
  42     /**
  43      * {@inheritdoc}
  44      */
  45     public function getUrl()
  46     {
  47         return 'import_pocket';
  48     }
  49
  50     /**
  51      * {@inheritdoc}
  52      */
  53     public function getDescription()
  54     {
  55         return 'import.pocket.description';
  56     }
  57
  58     /**
  59      * Return the oauth url to authenticate the client.
  60      *
  61      * @param string $redirectUri Redirect url in case of error
  62      *
  63      * @return string|false request_token for callback method
  64      */
  65     public function getRequestToken($redirectUri)
  66     {
  67         try {
  68             $response = $this->client->post('https://getpocket.com/v3/oauth/request', [], json_encode([
  69                 'consumer_key' => $this->user->getConfig()->getPocketConsumerKey(),
  70                 'redirect_uri' => $redirectUri,
  71             ]));
  72         } catch (RequestException $e) {
  73             $this->logger->error(sprintf('PocketImport: Failed to request token: %s', $e->getMessage()), ['exception' => $e]);
  74
  75             return false;
  76         }
  77
  78         return $this->jsonDecode($response)['code'];
  79     }
  80
  81     /**
  82      * Usually called by the previous callback to authorize the client.
  83      * Then it return a token that can be used for next requests.
  84      *
  85      * @param string $code request_token from getRequestToken
  86      *
  87      * @return bool
  88      */
  89     public function authorize($code)
  90     {
  91
  92         try {
  93             $response = $this->client->post('https://getpocket.com/v3/oauth/authorize', [], json_encode([
  94                 'consumer_key' => $this->user->getConfig()->getPocketConsumerKey(),
  95                 'code' => $code,
  96             ]));
  97         } catch (RequestException $e) {
  98             $this->logger->error(sprintf('PocketImport: Failed to authorize client: %s', $e->getMessage()), ['exception' => $e]);
  99
 100             return false;
 101         }
 102
 103         $this->accessToken = $this->jsonDecode($response)['access_token'];
 104
 105         return true;
 106     }
 107
 108     /**
 109      * {@inheritdoc}
 110      */
 111     public function import($offset = 0)
 112     {
 113         static $run = 0;
 114
 115         try {
 116             $response = $this->client->post('https://getpocket.com/v3/get', [], json_encode([
 117                 'consumer_key' => $this->user->getConfig()->getPocketConsumerKey(),
 118                 'access_token' => $this->accessToken,
 119                 'detailType' => 'complete',
 120                 'state' => 'all',
 121                 'sort' => 'newest',
 122                 'count' => self::NB_ELEMENTS,
 123                 'offset' => $offset,
 124             ]));
 125         } catch (RequestException $e) {
 126             $this->logger->error(sprintf('PocketImport: Failed to import: %s', $e->getMessage()), ['exception' => $e]);
 127
 128             return false;
 129         }
 130
 131         $entries = $this->jsonDecode($response);
 132
 133         if ($this->producer) {
 134             $this->parseEntriesForProducer($entries['list']);
 135         } else {
 136             $this->parseEntries($entries['list']);
 137         }
 138
 139         // if we retrieve exactly the amount of items requested it means we can get more
 140         // re-call import and offset item by the amount previous received:
 141         //  - first call get 5k offset 0
 142         //  - second call get 5k offset 5k
 143         //  - and so on
 144         if (self::NB_ELEMENTS === \count($entries['list'])) {
 145             ++$run;
 146
 147             return $this->import(self::NB_ELEMENTS * $run);
 148         }
 149
 150         return true;
 151     }
 152
 153     /**
 154      * Set the Http client.
 155      *
 156      * @param HttpClient $client
 157      * @param MessageFactory|null $messageFactory
 158      */
 159     public function setClient(HttpClient $client, MessageFactory $messageFactory = null)
 160     {
 161         $this->client = new HttpMethodsClient(new PluginClient($client, [new ErrorPlugin()]), $messageFactory ?: MessageFactoryDiscovery::find());
 162     }
 163
 164     /**
 165      * {@inheritdoc}
 166      */
 167     public function validateEntry(array $importedEntry)
 168     {
 169         if (empty($importedEntry['resolved_url']) && empty($importedEntry['given_url'])) {
 170             return false;
 171         }
 172
 173         return true;
 174     }
 175
 176     /**
 177      * {@inheritdoc}
 178      *
 179      * @see https://getpocket.com/developer/docs/v3/retrieve
 180      */
 181     public function parseEntry(array $importedEntry)
 182     {
 183         $url = isset($importedEntry['resolved_url']) && '' !== $importedEntry['resolved_url'] ? $importedEntry['resolved_url'] : $importedEntry['given_url'];
 184
 185         $existingEntry = $this->em
 186             ->getRepository('WallabagCoreBundle:Entry')
 187             ->findByUrlAndUserId($url, $this->user->getId());
 188
 189         if (false !== $existingEntry) {
 190             ++$this->skippedEntries;
 191
 192             return;
 193         }
 194
 195         $entry = new Entry($this->user);
 196         $entry->setUrl($url);
 197
 198         // update entry with content (in case fetching failed, the given entry will be return)
 199         $this->fetchContent($entry, $url);
 200
 201         // 0, 1, 2 - 1 if the item is archived - 2 if the item should be deleted
 202         $entry->updateArchived(1 === (int) $importedEntry['status'] || $this->markAsRead);
 203
 204         // 0 or 1 - 1 if the item is starred
 205         $entry->setStarred(1 === (int) $importedEntry['favorite']);
 206
 207         $title = 'Untitled';
 208         if (isset($importedEntry['resolved_title']) && '' !== $importedEntry['resolved_title']) {
 209             $title = $importedEntry['resolved_title'];
 210         } elseif (isset($importedEntry['given_title']) && '' !== $importedEntry['given_title']) {
 211             $title = $importedEntry['given_title'];
 212         }
 213
 214         $entry->setTitle($title);
 215
 216         // 0, 1, or 2 - 1 if the item has images in it - 2 if the item is an image
 217         if (isset($importedEntry['has_image']) && $importedEntry['has_image'] > 0 && isset($importedEntry['images'][1])) {
 218             $entry->setPreviewPicture($importedEntry['images'][1]['src']);
 219         }
 220
 221         if (isset($importedEntry['tags']) && !empty($importedEntry['tags'])) {
 222             $this->tagsAssigner->assignTagsToEntry(
 223                 $entry,
 224                 array_keys($importedEntry['tags']),
 225                 $this->em->getUnitOfWork()->getScheduledEntityInsertions()
 226             );
 227         }
 228
 229         if (!empty($importedEntry['time_added'])) {
 230             $entry->setCreatedAt((new \DateTime())->setTimestamp($importedEntry['time_added']));
 231         }
 232
 233         $this->em->persist($entry);
 234         ++$this->importedEntries;
 235
 236         return $entry;
 237     }
 238
 239     /**
 240      * {@inheritdoc}
 241      */
 242     protected function setEntryAsRead(array $importedEntry)
 243     {
 244         $importedEntry['status'] = '1';
 245
 246         return $importedEntry;
 247     }
 248
 249     protected function jsonDecode(ResponseInterface $response)
 250     {
 251         $data = \json_decode((string) $response->getBody(), true);
 252
 253         if (JSON_ERROR_NONE !== json_last_error()) {
 254             throw new \InvalidArgumentException('Unable to parse JSON data: ' . json_last_error_msg());
 255         }
 256
 257         return $data;
 258     }
 259 }