twitter/twitter.php

   1 <?php
   2 /**
   3  * Name: Twitter Connector
   4  * Description: Bidirectional (posting, relaying and reading) connector for Twitter.
   5  * Version: 1.1.0
   6  * Author: Tobias Diekershoff <https://f.diekershoff.de/profile/tobias>
   7  * Author: Michael Vogel <https://pirati.ca/profile/heluecht>
   8  * Maintainer: Hypolite Petovan <https://friendica.mrpetovan.com/profile/hypolite>
   9  *
  10  * Copyright (c) 2011-2013 Tobias Diekershoff, Michael Vogel, Hypolite Petovan
  11  * All rights reserved.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions are met:
  15  *    * Redistributions of source code must retain the above copyright notice,
  16  *     this list of conditions and the following disclaimer.
  17  *    * Redistributions in binary form must reproduce the above
  18  *    * copyright notice, this list of conditions and the following disclaimer in
  19  *      the documentation and/or other materials provided with the distribution.
  20  *    * Neither the name of the <organization> nor the names of its contributors
  21  *      may be used to endorse or promote products derived from this software
  22  *      without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  26  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  27  * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY DIRECT,
  28  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  29  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  30  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  32  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  33  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  */
  36 /*   Twitter Addon for Friendica
  37  *
  38  *   Author: Tobias Diekershoff
  39  *           tobias.diekershoff@gmx.net
  40  *
  41  *   License:3-clause BSD license
  42  *
  43  *   Configuration:
  44  *     To use this addon you need a OAuth Consumer key pair (key & secret)
  45  *     you can get it from Twitter at https://twitter.com/apps
  46  *
  47  *     Register your Friendica site as "Client" application with "Read & Write" access
  48  *     we do not need "Twitter as login". When you've registered the app you get the
  49  *     OAuth Consumer key and secret pair for your application/site.
  50  *
  51  *     Add this key pair to your global config/addon.config.php or use the admin panel.
  52  *
  53  *      'twitter' => [
  54  *                  'consumerkey' => '',
  55  *              'consumersecret' => '',
  56  *      ],
  57  *
  58  *     To activate the addon itself add it to the system.addon
  59  *     setting. After this, your user can configure their Twitter account settings
  60  *     from "Settings -> Addon Settings".
  61  *
  62  *     Requirements: PHP5, curl
  63  */
  64
  65 use Abraham\TwitterOAuth\TwitterOAuth;
  66 use Abraham\TwitterOAuth\TwitterOAuthException;
  67 use Codebird\Codebird;
  68 use Friendica\App;
  69 use Friendica\Content\Text\BBCode;
  70 use Friendica\Content\Text\Plaintext;
  71 use Friendica\Core\Hook;
  72 use Friendica\Core\Logger;
  73 use Friendica\Core\Protocol;
  74 use Friendica\Core\Renderer;
  75 use Friendica\Core\Worker;
  76 use Friendica\Database\DBA;
  77 use Friendica\DI;
  78 use Friendica\Model\Contact;
  79 use Friendica\Model\Conversation;
  80 use Friendica\Model\Group;
  81 use Friendica\Model\Item;
  82 use Friendica\Model\ItemURI;
  83 use Friendica\Model\Post;
  84 use Friendica\Model\Tag;
  85 use Friendica\Model\User;
  86 use Friendica\Protocol\Activity;
  87 use Friendica\Core\Config\Util\ConfigFileLoader;
  88 use Friendica\Core\System;
  89 use Friendica\Util\DateTimeFormat;
  90 use Friendica\Util\Images;
  91 use Friendica\Util\Strings;
  92
  93 require_once __DIR__ . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
  94
  95 define('TWITTER_DEFAULT_POLL_INTERVAL', 5); // given in minutes
  96
  97 function twitter_install()
  98 {
  99         //  we need some hooks, for the configuration and for sending tweets
 100         Hook::register('load_config'            , __FILE__, 'twitter_load_config');
 101         Hook::register('connector_settings'     , __FILE__, 'twitter_settings');
 102         Hook::register('connector_settings_post', __FILE__, 'twitter_settings_post');
 103         Hook::register('hook_fork'              , __FILE__, 'twitter_hook_fork');
 104         Hook::register('post_local'             , __FILE__, 'twitter_post_local');
 105         Hook::register('notifier_normal'        , __FILE__, 'twitter_post_hook');
 106         Hook::register('jot_networks'           , __FILE__, 'twitter_jot_nets');
 107         Hook::register('cron'                   , __FILE__, 'twitter_cron');
 108         Hook::register('support_follow'         , __FILE__, 'twitter_support_follow');
 109         Hook::register('follow'                 , __FILE__, 'twitter_follow');
 110         Hook::register('unfollow'               , __FILE__, 'twitter_unfollow');
 111         Hook::register('block'                  , __FILE__, 'twitter_block');
 112         Hook::register('unblock'                , __FILE__, 'twitter_unblock');
 113         Hook::register('expire'                 , __FILE__, 'twitter_expire');
 114         Hook::register('prepare_body'           , __FILE__, 'twitter_prepare_body');
 115         Hook::register('check_item_notification', __FILE__, 'twitter_check_item_notification');
 116         Hook::register('probe_detect'           , __FILE__, 'twitter_probe_detect');
 117         Hook::register('item_by_link'           , __FILE__, 'twitter_item_by_link');
 118         Hook::register('parse_link'             , __FILE__, 'twitter_parse_link');
 119         Logger::info("installed twitter");
 120 }
 121
 122 // Hook functions
 123
 124 function twitter_load_config(App $a, ConfigFileLoader $loader)
 125 {
 126         $a->getConfigCache()->load($loader->loadAddonConfig('twitter'));
 127 }
 128
 129 function twitter_check_item_notification(App $a, array &$notification_data)
 130 {
 131         $own_id = DI::pConfig()->get($notification_data['uid'], 'twitter', 'own_id');
 132
 133         $own_user = Contact::selectFirst(['url'], ['uid' => $notification_data['uid'], 'alias' => 'twitter::'.$own_id]);
 134         if ($own_user) {
 135                 $notification_data['profiles'][] = $own_user['url'];
 136         }
 137 }
 138
 139 function twitter_support_follow(App $a, array &$data)
 140 {
 141         if ($data['protocol'] == Protocol::TWITTER) {
 142                 $data['result'] = true;
 143         }
 144 }
 145
 146 function twitter_follow(App $a, array &$contact)
 147 {
 148         Logger::info('Check if contact is twitter contact', ['url' => $contact["url"]]);
 149
 150         if (!strstr($contact["url"], "://twitter.com") && !strstr($contact["url"], "@twitter.com")) {
 151                 return;
 152         }
 153
 154         // contact seems to be a twitter contact, so continue
 155         $nickname = preg_replace("=https?://twitter.com/(.*)=ism", "$1", $contact["url"]);
 156         $nickname = str_replace("@twitter.com", "", $nickname);
 157
 158         $uid = $a->getLoggedInUserId();
 159
 160         if (!twitter_api_contact('friendships/create', ['network' => Protocol::TWITTER, 'nick' => $nickname], $uid)) {
 161                 $contact = null;
 162                 return;
 163         }
 164
 165         $user = twitter_fetchuser($nickname);
 166
 167         $contact_id = twitter_fetch_contact($uid, $user, true);
 168
 169         $contact = Contact::getById($contact_id, ['name', 'nick', 'url', 'addr', 'batch', 'notify', 'poll', 'request', 'confirm', 'poco', 'photo', 'priority', 'network', 'alias', 'pubkey']);
 170
 171         if (DBA::isResult($contact)) {
 172                 $contact["contact"] = $contact;
 173         }
 174 }
 175
 176 function twitter_unfollow(App $a, array &$hook_data)
 177 {
 178         $hook_data['result'] = twitter_api_contact('friendships/destroy', $hook_data['contact'], $hook_data['uid']);
 179 }
 180
 181 function twitter_block(App $a, array &$hook_data)
 182 {
 183         $hook_data['result'] = twitter_api_contact('blocks/create', $hook_data['contact'], $hook_data['uid']);
 184
 185         if ($hook_data['result'] === true) {
 186                 $cdata = Contact::getPublicAndUserContactID($hook_data['contact']['id'], $hook_data['uid']);
 187                 Contact::remove($cdata['user']);
 188         }
 189 }
 190
 191 function twitter_unblock(App $a, array &$hook_data)
 192 {
 193         $hook_data['result'] = twitter_api_contact('blocks/destroy', $hook_data['contact'], $hook_data['uid']);
 194 }
 195
 196 function twitter_api_contact(string $apiPath, array $contact, int $uid): ?bool
 197 {
 198         if ($contact['network'] !== Protocol::TWITTER) {
 199                 return null;
 200         }
 201
 202         return twitter_api_call($uid, $apiPath, ['screen_name' => $contact['nick']]);
 203 }
 204
 205 function twitter_jot_nets(App $a, array &$jotnets_fields)
 206 {
 207         if (!local_user()) {
 208                 return;
 209         }
 210
 211         if (DI::pConfig()->get(local_user(), 'twitter', 'post')) {
 212                 $jotnets_fields[] = [
 213                         'type' => 'checkbox',
 214                         'field' => [
 215                                 'twitter_enable',
 216                                 DI::l10n()->t('Post to Twitter'),
 217                                 DI::pConfig()->get(local_user(), 'twitter', 'post_by_default')
 218                         ]
 219                 ];
 220         }
 221 }
 222
 223
 224 function twitter_settings_post(App $a)
 225 {
 226         if (!local_user()) {
 227                 return;
 228         }
 229         // don't check twitter settings if twitter submit button is not clicked
 230         if (empty($_POST['twitter-disconnect']) && empty($_POST['twitter-submit'])) {
 231                 return;
 232         }
 233
 234         if (!empty($_POST['twitter-disconnect'])) {
 235                 /*               * *
 236                  * if the twitter-disconnect checkbox is set, clear the OAuth key/secret pair
 237                  * from the user configuration
 238                  */
 239                 DI::pConfig()->delete(local_user(), 'twitter', 'consumerkey');
 240                 DI::pConfig()->delete(local_user(), 'twitter', 'consumersecret');
 241                 DI::pConfig()->delete(local_user(), 'twitter', 'oauthtoken');
 242                 DI::pConfig()->delete(local_user(), 'twitter', 'oauthsecret');
 243                 DI::pConfig()->delete(local_user(), 'twitter', 'post');
 244                 DI::pConfig()->delete(local_user(), 'twitter', 'post_by_default');
 245                 DI::pConfig()->delete(local_user(), 'twitter', 'lastid');
 246                 DI::pConfig()->delete(local_user(), 'twitter', 'mirror_posts');
 247                 DI::pConfig()->delete(local_user(), 'twitter', 'import');
 248                 DI::pConfig()->delete(local_user(), 'twitter', 'create_user');
 249                 DI::pConfig()->delete(local_user(), 'twitter', 'own_id');
 250         } else {
 251                 if (isset($_POST['twitter-pin'])) {
 252                         //  if the user supplied us with a PIN from Twitter, let the magic of OAuth happen
 253                         Logger::notice('got a Twitter PIN');
 254                         $ckey    = DI::config()->get('twitter', 'consumerkey');
 255                         $csecret = DI::config()->get('twitter', 'consumersecret');
 256                         //  the token and secret for which the PIN was generated were hidden in the settings
 257                         //  form as token and token2, we need a new connection to Twitter using these token
 258                         //  and secret to request a Access Token with the PIN
 259                         try {
 260                                 if (empty($_POST['twitter-pin'])) {
 261                                         throw new Exception(DI::l10n()->t('You submitted an empty PIN, please Sign In with Twitter again to get a new one.'));
 262                                 }
 263
 264                                 $connection = new TwitterOAuth($ckey, $csecret, $_POST['twitter-token'], $_POST['twitter-token2']);
 265                                 $token = $connection->oauth("oauth/access_token", ["oauth_verifier" => $_POST['twitter-pin']]);
 266                                 //  ok, now that we have the Access Token, save them in the user config
 267                                 DI::pConfig()->set(local_user(), 'twitter', 'oauthtoken', $token['oauth_token']);
 268                                 DI::pConfig()->set(local_user(), 'twitter', 'oauthsecret', $token['oauth_token_secret']);
 269                                 DI::pConfig()->set(local_user(), 'twitter', 'post', 1);
 270                         } catch(Exception $e) {
 271                                 notice($e->getMessage());
 272                         } catch(TwitterOAuthException $e) {
 273                                 notice($e->getMessage());
 274                         }
 275                 } else {
 276                         //  if no PIN is supplied in the POST variables, the user has changed the setting
 277                         //  to post a tweet for every new __public__ posting to the wall
 278                         DI::pConfig()->set(local_user(), 'twitter', 'post', intval($_POST['twitter-enable']));
 279                         DI::pConfig()->set(local_user(), 'twitter', 'post_by_default', intval($_POST['twitter-default']));
 280                         DI::pConfig()->set(local_user(), 'twitter', 'mirror_posts', intval($_POST['twitter-mirror']));
 281                         DI::pConfig()->set(local_user(), 'twitter', 'import', intval($_POST['twitter-import']));
 282                         DI::pConfig()->set(local_user(), 'twitter', 'create_user', intval($_POST['twitter-create_user']));
 283
 284                         if (!intval($_POST['twitter-mirror'])) {
 285                                 DI::pConfig()->delete(local_user(), 'twitter', 'lastid');
 286                         }
 287                 }
 288         }
 289 }
 290
 291 function twitter_settings(App $a, array &$data)
 292 {
 293         if (!local_user()) {
 294                 return;
 295         }
 296
 297         $user = User::getById(local_user());
 298
 299         DI::page()->registerStylesheet(__DIR__ . '/twitter.css', 'all');
 300
 301         /*       * *
 302          * 1) Check that we have global consumer key & secret
 303          * 2) If no OAuthtoken & stuff is present, generate button to get some
 304          * 3) Checkbox for "Send public notices (280 chars only)
 305          */
 306         $ckey    = DI::config()->get('twitter', 'consumerkey');
 307         $csecret = DI::config()->get('twitter', 'consumersecret');
 308         $otoken  = DI::pConfig()->get(local_user(), 'twitter', 'oauthtoken');
 309         $osecret = DI::pConfig()->get(local_user(), 'twitter', 'oauthsecret');
 310
 311         $enabled            = intval(DI::pConfig()->get(local_user(), 'twitter', 'post'));
 312         $defenabled         = intval(DI::pConfig()->get(local_user(), 'twitter', 'post_by_default'));
 313         $mirrorenabled      = intval(DI::pConfig()->get(local_user(), 'twitter', 'mirror_posts'));
 314         $importenabled      = intval(DI::pConfig()->get(local_user(), 'twitter', 'import'));
 315         $create_userenabled = intval(DI::pConfig()->get(local_user(), 'twitter', 'create_user'));
 316
 317         // Hide the submit button by default
 318         $submit = '';
 319
 320         if ((!$ckey) && (!$csecret)) {
 321                 /* no global consumer keys
 322                  * display warning and skip personal config
 323                  */
 324                 $html = '<p>' . DI::l10n()->t('No consumer key pair for Twitter found. Please contact your site administrator.') . '</p>';
 325         } else {
 326                 // ok we have a consumer key pair now look into the OAuth stuff
 327                 if ((!$otoken) && (!$osecret)) {
 328                         /* the user has not yet connected the account to twitter...
 329                          * get a temporary OAuth key/secret pair and display a button with
 330                          * which the user can request a PIN to connect the account to a
 331                          * account at Twitter.
 332                          */
 333                         $connection = new TwitterOAuth($ckey, $csecret);
 334                         try {
 335                                 $result = $connection->oauth('oauth/request_token', ['oauth_callback' => 'oob']);
 336
 337                                 $html = '<p>' . DI::l10n()->t('At this Friendica instance the Twitter addon was enabled but you have not yet connected your account to your Twitter account. To do so click the button below to get a PIN from Twitter which you have to copy into the input box below and submit the form. Only your <strong>public</strong> posts will be posted to Twitter.') . '</p>';
 338                                 $html .= '<a href="' . $connection->url('oauth/authorize', ['oauth_token' => $result['oauth_token']]) . '" target="_twitter"><img src="addon/twitter/lighter.png" alt="' . DI::l10n()->t('Log in with Twitter') . '"></a>';
 339                                 $html .= '<div id="twitter-pin-wrapper">';
 340                                 $html .= '<label id="twitter-pin-label" for="twitter-pin">' . DI::l10n()->t('Copy the PIN from Twitter here') . '</label>';
 341                                 $html .= '<input id="twitter-pin" type="text" name="twitter-pin" />';
 342                                 $html .= '<input id="twitter-token" type="hidden" name="twitter-token" value="' . $result['oauth_token'] . '" />';
 343                                 $html .= '<input id="twitter-token2" type="hidden" name="twitter-token2" value="' . $result['oauth_token_secret'] . '" />';
 344                                 $html .= '</div>';
 345
 346                                 $submit = null;
 347                         } catch (TwitterOAuthException $e) {
 348                                 $html = '<p>' . DI::l10n()->t('An error occured: ') . $e->getMessage() . '</p>';
 349                         }
 350                 } else {
 351                         /*                       * *
 352                          *  we have an OAuth key / secret pair for the user
 353                          *  so let's give a chance to disable the postings to Twitter
 354                          */
 355                         $connection = new TwitterOAuth($ckey, $csecret, $otoken, $osecret);
 356                         try {
 357                                 $account = $connection->get('account/verify_credentials');
 358                                 if (property_exists($account, 'screen_name') &&
 359                                         property_exists($account, 'description') &&
 360                                         property_exists($account, 'profile_image_url')
 361                                 ) {
 362                                         $connected = DI::l10n()->t('Currently connected to: <a href="https://twitter.com/%1$s" target="_twitter">%1$s</a>', $account->screen_name);
 363                                 } else {
 364                                         Logger::notice('Invalid twitter info (verify credentials).', ['auth' => TwitterOAuth::class]);
 365                                 }
 366
 367                                 if ($user['hidewall']) {
 368                                         $privacy_warning = DI::l10n()->t('<strong>Note</strong>: Due to your privacy settings (<em>Hide your profile details from unknown viewers?</em>) the link potentially included in public postings relayed to Twitter will lead the visitor to a blank page informing the visitor that the access to your profile has been restricted.');
 369                                 }
 370
 371                                 $t    = Renderer::getMarkupTemplate('connector_settings.tpl', 'addon/twitter/');
 372                                 $html = Renderer::replaceMacros($t, [
 373                                         '$l10n' => [
 374                                                 'connected'       => $connected ?? '',
 375                                                 'invalid'         => DI::l10n()->t('Invalid Twitter info'),
 376                                                 'disconnect'      => DI::l10n()->t('Disconnect'),
 377                                                 'privacy_warning' => $privacy_warning ?? '',
 378                                         ],
 379
 380                                         '$account'     => $account,
 381                                         '$enable'      => ['twitter-enable', DI::l10n()->t('Allow posting to Twitter'), $enabled, DI::l10n()->t('If enabled all your <strong>public</strong> postings can be posted to the associated Twitter account. You can choose to do so by default (here) or for every posting separately in the posting options when writing the entry.')],
 382                                         '$default'     => ['twitter-default', DI::l10n()->t('Send public postings to Twitter by default'), $defenabled],
 383                                         '$mirror'      => ['twitter-mirror', DI::l10n()->t('Mirror all posts from twitter that are no replies'), $mirrorenabled],
 384                                         '$import'      => ['twitter-import', DI::l10n()->t('Import the remote timeline'), $importenabled],
 385                                         '$create_user' => ['twitter-create_user', DI::l10n()->t('Automatically create contacts'), $create_userenabled, DI::l10n()->t('This will automatically create a contact in Friendica as soon as you receive a message from an existing contact via the Twitter network. If you do not enable this, you need to manually add those Twitter contacts in Friendica from whom you would like to see posts here.')],
 386                                 ]);
 387
 388                                 // Enable the default submit button
 389                                 $submit = null;
 390                         } catch (TwitterOAuthException $e) {
 391                                 $html = '<p>' . DI::l10n()->t('An error occured: ') . $e->getMessage() . '</p>';
 392                         }
 393                 }
 394         }
 395
 396         $data = [
 397                 'connector' => 'twitter',
 398                 'title'     => DI::l10n()->t('Twitter Import/Export/Mirror'),
 399                 'enabled'   => $enabled,
 400                 'image'     => 'images/twitter.png',
 401                 'html'      => $html,
 402                 'submit'    => $submit ?? null,
 403         ];
 404 }
 405
 406 function twitter_hook_fork(App $a, array &$b)
 407 {
 408         DI::logger()->debug('twitter_hook_fork', $b);
 409
 410         if ($b['name'] != 'notifier_normal') {
 411                 return;
 412         }
 413
 414         $post = $b['data'];
 415
 416         // Deletion checks are done in twitter_delete_item()
 417         if ($post['deleted']) {
 418                 return;
 419         }
 420
 421         // Editing is not supported by the addon
 422         if ($post['created'] !== $post['edited']) {
 423                 DI::logger()->info('Editing is not supported by the addon');
 424                 $b['execute'] = false;
 425                 return;
 426         }
 427
 428         // if post comes from twitter don't send it back
 429         if (($post['extid'] == Protocol::TWITTER) || twitter_get_id($post['extid'])) {
 430                 DI::logger()->info('If post comes from twitter don\'t send it back');
 431                 $b['execute'] = false;
 432                 return;
 433         }
 434
 435         if (substr($post['app'], 0, 7) == 'Twitter') {
 436                 DI::logger()->info('No Twitter app');
 437                 $b['execute'] = false;
 438                 return;
 439         }
 440
 441         if (DI::pConfig()->get($post['uid'], 'twitter', 'import')) {
 442                 // Don't fork if it isn't a reply to a twitter post
 443                 if (($post['parent'] != $post['id']) && !Post::exists(['id' => $post['parent'], 'network' => Protocol::TWITTER])) {
 444                         Logger::notice('No twitter parent found', ['item' => $post['id']]);
 445                         $b['execute'] = false;
 446                         return;
 447                 }
 448         } else {
 449                 // Comments are never exported when we don't import the twitter timeline
 450                 if (!strstr($post['postopts'], 'twitter') || ($post['parent'] != $post['id']) || $post['private']) {
 451                         DI::logger()->info('Comments are never exported when we don\'t import the twitter timeline');
 452                         $b['execute'] = false;
 453                         return;
 454                 }
 455     }
 456 }
 457
 458 function twitter_post_local(App $a, array &$b)
 459 {
 460         if ($b['edit']) {
 461                 return;
 462         }
 463
 464         if (!local_user() || (local_user() != $b['uid'])) {
 465                 return;
 466         }
 467
 468         $twitter_post = intval(DI::pConfig()->get(local_user(), 'twitter', 'post'));
 469         $twitter_enable = (($twitter_post && !empty($_REQUEST['twitter_enable'])) ? intval($_REQUEST['twitter_enable']) : 0);
 470
 471         // if API is used, default to the chosen settings
 472         if ($b['api_source'] && intval(DI::pConfig()->get(local_user(), 'twitter', 'post_by_default'))) {
 473                 $twitter_enable = 1;
 474         }
 475
 476         if (!$twitter_enable) {
 477                 return;
 478         }
 479
 480         if (strlen($b['postopts'])) {
 481                 $b['postopts'] .= ',';
 482         }
 483
 484         $b['postopts'] .= 'twitter';
 485 }
 486
 487 function twitter_probe_detect(App $a, array &$hookData)
 488 {
 489         // Don't overwrite an existing result
 490         if (isset($hookData['result'])) {
 491                 return;
 492         }
 493
 494         // Avoid a lookup for the wrong network
 495         if (!in_array($hookData['network'], ['', Protocol::TWITTER])) {
 496                 return;
 497         }
 498
 499         if (preg_match('=([^@]+)@(?:mobile\.)?twitter\.com$=i', $hookData['uri'], $matches)) {
 500                 $nick = $matches[1];
 501         } elseif (preg_match('=^https?://(?:mobile\.)?twitter\.com/(.+)=i', $hookData['uri'], $matches)) {
 502                 if (strpos($matches[1], '/') !== false) {
 503                         // Status case: https://twitter.com/<nick>/status/<status id>
 504                         // Not a contact
 505                         $hookData['result'] = false;
 506                         return;
 507                 }
 508
 509                 $nick = $matches[1];
 510         } else {
 511                 return;
 512         }
 513
 514         $user = twitter_fetchuser($nick);
 515
 516         if ($user) {
 517                 $hookData['result'] = twitter_user_to_contact($user);
 518         }
 519 }
 520
 521 function twitter_item_by_link(App $a, array &$hookData)
 522 {
 523         // Don't overwrite an existing result
 524         if (isset($hookData['item_id'])) {
 525                 return;
 526         }
 527
 528         // Relevancy check
 529         if (!preg_match('#^https?://(?:mobile\.|www\.)?twitter.com/[^/]+/status/(\d+).*#', $hookData['uri'], $matches)) {
 530                 return;
 531         }
 532
 533         // From now on, any early return should abort the whole chain since we've established it was a Twitter URL
 534         $hookData['item_id'] = false;
 535
 536         // Node-level configuration check
 537         if (empty(DI::config()->get('twitter', 'consumerkey')) || empty(DI::config()->get('twitter', 'consumersecret'))) {
 538                 return;
 539         }
 540
 541         // No anonymous import
 542         if (!$hookData['uid']) {
 543                 return;
 544         }
 545
 546         if (
 547                 empty(DI::pConfig()->get($hookData['uid'], 'twitter', 'oauthtoken'))
 548                 || empty(DI::pConfig()->get($hookData['uid'], 'twitter', 'oauthsecret'))
 549         ) {
 550                 notice(DI::l10n()->t('Please connect a Twitter account in your Social Network settings to import Twitter posts.'));
 551                 return;
 552         }
 553
 554         $status = twitter_statuses_show($matches[1]);
 555
 556         if (empty($status->id_str)) {
 557                 notice(DI::l10n()->t('Twitter post not found.'));
 558                 return;
 559         }
 560
 561         $item = twitter_createpost($a, $hookData['uid'], $status, [], true, false, false);
 562         if (!empty($item)) {
 563                 $hookData['item_id'] = Item::insert($item);
 564         }
 565 }
 566
 567 function twitter_api_post(string $apiPath, string $pid, int $uid): ?bool
 568 {
 569         if (empty($pid)) {
 570                 return false;
 571         }
 572
 573         return twitter_api_call($uid, $apiPath, ['id' => $pid]);
 574 }
 575
 576 function twitter_api_call(int $uid, string $apiPath, array $parameters = []): ?bool
 577 {
 578         $ckey = DI::config()->get('twitter', 'consumerkey');
 579         $csecret = DI::config()->get('twitter', 'consumersecret');
 580         $otoken = DI::pConfig()->get($uid, 'twitter', 'oauthtoken');
 581         $osecret = DI::pConfig()->get($uid, 'twitter', 'oauthsecret');
 582
 583         // If the addon is not configured (general or for this user) quit here
 584         if (empty($ckey) || empty($csecret) || empty($otoken) || empty($osecret)) {
 585                 return null;
 586         }
 587
 588         try {
 589                 $connection = new TwitterOAuth($ckey, $csecret, $otoken, $osecret);
 590                 $result = $connection->post($apiPath, $parameters);
 591
 592                 if ($connection->getLastHttpCode() != 200) {
 593                         throw new Exception($result->errors[0]->message ?? json_encode($result), $connection->getLastHttpCode());
 594                 }
 595
 596                 if (!empty($result->errors)) {
 597                         throw new Exception($result->errors[0]->message, $result->errors[0]->code);
 598                 }
 599
 600                 Logger::info('[twitter] API call successful', ['apiPath' => $apiPath, 'parameters' => $parameters]);
 601                 Logger::debug('[twitter] API call result', ['apiPath' => $apiPath, 'parameters' => $parameters, 'result' => $result]);
 602
 603                 return true;
 604         } catch (TwitterOAuthException $twitterOAuthException) {
 605                 Logger::warning('Unable to communicate with twitter', ['apiPath' => $apiPath, 'parameters' => $parameters, 'code' => $twitterOAuthException->getCode(), 'exception' => $twitterOAuthException]);
 606                 return false;
 607         } catch (Exception $e) {
 608                 Logger::notice('[twitter] API call failed', ['apiPath' => $apiPath, 'parameters' => $parameters, 'code' => $e->getCode(), 'message' => $e->getMessage()]);
 609                 return false;
 610         }
 611 }
 612
 613 function twitter_get_id(string $uri)
 614 {
 615         if ((substr($uri, 0, 9) != 'twitter::') || (strlen($uri) <= 9)) {
 616                 return 0;
 617         }
 618
 619         $id = substr($uri, 9);
 620         if (!is_numeric($id)) {
 621                 return 0;
 622         }
 623
 624         return (int)$id;
 625 }
 626
 627 function twitter_post_hook(App $a, array &$b)
 628 {
 629         DI::logger()->info('twitter_post_hook', $b);
 630
 631         if ($b['deleted']) {
 632                 twitter_delete_item($b);
 633                 return;
 634         }
 635
 636         // Post to Twitter
 637         if (!DI::pConfig()->get($b["uid"], 'twitter', 'import')
 638                 && ($b['private'] || ($b['created'] !== $b['edited']))) {
 639                 return;
 640         }
 641
 642         $b['body'] = Post\Media::addAttachmentsToBody($b['uri-id'], $b['body']);
 643
 644         $thr_parent = null;
 645
 646         if ($b['parent'] != $b['id']) {
 647                 Logger::debug('Got comment', ['item' => $b]);
 648
 649                 // Looking if its a reply to a twitter post
 650                 if (!twitter_get_id($b["parent-uri"]) &&
 651                         !twitter_get_id($b["extid"]) &&
 652                         !twitter_get_id($b["thr-parent"])) {
 653                         Logger::info('No twitter post', ['parent' => $b["parent"]]);
 654                         return;
 655                 }
 656
 657                 $condition = ['uri' => $b["thr-parent"], 'uid' => $b["uid"]];
 658                 $thr_parent = Post::selectFirst(['uri', 'extid', 'author-link', 'author-nick', 'author-network'], $condition);
 659                 if (!DBA::isResult($thr_parent)) {
 660                         Logger::warning('No parent found', ['thr-parent' => $b["thr-parent"]]);
 661                         return;
 662                 }
 663
 664                 if ($thr_parent['author-network'] == Protocol::TWITTER) {
 665                         $nickname = '@[url=' . $thr_parent['author-link'] . ']' . $thr_parent['author-nick'] . '[/url]';
 666                         $nicknameplain = '@' . $thr_parent['author-nick'];
 667
 668                         Logger::info('Comparing', ['nickname' => $nickname, 'nicknameplain' => $nicknameplain, 'body' => $b["body"]]);
 669                         if ((strpos($b["body"], $nickname) === false) && (strpos($b["body"], $nicknameplain) === false)) {
 670                                 $b["body"] = $nickname . " " . $b["body"];
 671                         }
 672                 }
 673
 674                 Logger::debug('Parent found', ['parent' => $thr_parent]);
 675         } else {
 676                 if ($b['private'] || !strstr($b['postopts'], 'twitter')) {
 677                         return;
 678                 }
 679
 680                 // Dont't post if the post doesn't belong to us.
 681                 // This is a check for forum postings
 682                 $self = DBA::selectFirst('contact', ['id'], ['uid' => $b['uid'], 'self' => true]);
 683                 if ($b['contact-id'] != $self['id']) {
 684                         return;
 685                 }
 686         }
 687
 688         if ($b['verb'] == Activity::LIKE) {
 689                 Logger::info('Like', ['uid' => $b['uid'], 'id' => twitter_get_id($b["thr-parent"])]);
 690
 691                 twitter_api_post('favorites/create', twitter_get_id($b['thr-parent']), $b['uid']);
 692
 693                 return;
 694         }
 695
 696         if ($b['verb'] == Activity::ANNOUNCE) {
 697                 Logger::info('Retweet', ['uid' => $b['uid'], 'id' => twitter_get_id($b["thr-parent"])]);
 698                 twitter_retweet($b['uid'], twitter_get_id($b['thr-parent']));
 699                 return;
 700         }
 701
 702         if ($b['created'] !== $b['edited']) {
 703                 return;
 704         }
 705
 706         // if post comes from twitter don't send it back
 707         if (($b['extid'] == Protocol::TWITTER) || twitter_get_id($b['extid'])) {
 708                 return;
 709         }
 710
 711         if ($b['app'] == "Twitter") {
 712                 return;
 713         }
 714
 715         Logger::notice('twitter post invoked', ['id' => $b['id'], 'guid' => $b['guid']]);
 716
 717         DI::pConfig()->load($b['uid'], 'twitter');
 718
 719         $ckey    = DI::config()->get('twitter', 'consumerkey');
 720         $csecret = DI::config()->get('twitter', 'consumersecret');
 721         $otoken  = DI::pConfig()->get($b['uid'], 'twitter', 'oauthtoken');
 722         $osecret = DI::pConfig()->get($b['uid'], 'twitter', 'oauthsecret');
 723
 724         if ($ckey && $csecret && $otoken && $osecret) {
 725                 Logger::info('We have customer key and oauth stuff, going to send.');
 726
 727                 // If it's a repeated message from twitter then do a native retweet and exit
 728                 if (twitter_is_retweet($a, $b['uid'], $b['body'])) {
 729                         return;
 730                 }
 731
 732                 Codebird::setConsumerKey($ckey, $csecret);
 733                 $cb = Codebird::getInstance();
 734                 $cb->setToken($otoken, $osecret);
 735
 736                 $connection = new TwitterOAuth($ckey, $csecret, $otoken, $osecret);
 737
 738                 // Set the timeout for upload to 30 seconds
 739                 $connection->setTimeouts(10, 30);
 740
 741                 $max_char = 280;
 742
 743                 // Handling non-native reshares
 744                 $b['body'] = Friendica\Content\Text\BBCode::convertShare(
 745                         $b['body'],
 746                         function (array $attributes, array $author_contact, $content, $is_quote_share) {
 747                                 return twitter_convert_share($attributes, $author_contact, $content, $is_quote_share);
 748                         }
 749                 );
 750
 751                 $b['body'] = twitter_update_mentions($b['body']);
 752
 753                 $msgarr = Plaintext::getPost($b, $max_char, true, BBCode::TWITTER);
 754                 Logger::info('Got plaintext', ['id' => $b['id'], 'message' => $msgarr]);
 755                 $msg = $msgarr["text"];
 756
 757                 if (($msg == "") && isset($msgarr["title"])) {
 758                         $msg = Plaintext::shorten($msgarr["title"], $max_char - 50, $b['uid']);
 759                 }
 760
 761                 // Add the link to the body if the type isn't a photo or there are more than 4 images in the post
 762                 if (!empty($msgarr['url']) && (strpos($msg, $msgarr['url']) === false) && (($msgarr['type'] != 'photo') || empty($msgarr['images']) || (count($msgarr['images']) > 4))) {
 763                         $msg .= "\n" . $msgarr['url'];
 764                 }
 765
 766                 if (empty($msg)) {
 767                         Logger::notice('Empty message', ['id' => $b['id']]);
 768                         return;
 769                 }
 770
 771                 // and now tweet it :-)
 772                 $post = [];
 773
 774                 if (!empty($msgarr['images'])) {
 775                         Logger::info('Got images', ['id' => $b['id'], 'images' => $msgarr['images']]);
 776                         try {
 777                                 $media_ids = [];
 778                                 foreach ($msgarr['images'] as $image) {
 779                                         if (count($media_ids) == 4) {
 780                                                 continue;
 781                                         }
 782
 783                                         $img_str = DI::httpClient()->fetch($image['url']);
 784
 785                                         $tempfile = tempnam(System::getTempPath(), 'cache');
 786                                         file_put_contents($tempfile, $img_str);
 787
 788                                         Logger::info('Uploading', ['id' => $b['id'], 'image' => $image['url']]);
 789                                         $media = $connection->upload('media/upload', ['media' => $tempfile]);
 790
 791                                         unlink($tempfile);
 792
 793                                         if (isset($media->media_id_string)) {
 794                                                 $media_ids[] = $media->media_id_string;
 795
 796                                                 if (!empty($image['description'])) {
 797                                                         $data = ['media_id' => $media->media_id_string,
 798                                                                 'alt_text' => ['text' => substr($image['description'], 0, 420)]];
 799                                                         $ret = $cb->media_metadata_create($data);
 800                                                         Logger::info('Metadata create', ['id' => $b['id'], 'data' => $data, 'return' => $ret]);
 801                                                 }
 802                                         } else {
 803                                                 Logger::error('Failed upload', ['id' => $b['id'], 'image' => $image['url'], 'return' => $media]);
 804                                                 throw new Exception('Failed upload of ' . $image['url']);
 805                                         }
 806                                 }
 807                                 $post['media_ids'] = implode(',', $media_ids);
 808                                 if (empty($post['media_ids'])) {
 809                                         unset($post['media_ids']);
 810                                 }
 811                         } catch (Exception $e) {
 812                                 Logger::warning('Exception when trying to send to Twitter', ['id' => $b['id'], 'message' => $e->getMessage()]);
 813                         }
 814                 }
 815
 816                 $post['status'] = $msg;
 817
 818                 if ($thr_parent) {
 819                         $post['in_reply_to_status_id'] = twitter_get_id($thr_parent['uri']);
 820                 }
 821
 822                 $result = $connection->post('statuses/update', $post);
 823                 Logger::info('twitter_post send', ['id' => $b['id'], 'result' => $result]);
 824
 825                 if (!empty($result->source)) {
 826                         DI::config()->set("twitter", "application_name", strip_tags($result->source));
 827                 }
 828
 829                 if (!empty($result->errors)) {
 830                         Logger::error('Send to Twitter failed', ['id' => $b['id'], 'error' => $result->errors]);
 831                         Worker::defer();
 832                 } elseif ($thr_parent) {
 833                         Logger::notice('Post send, updating extid', ['id' => $b['id'], 'extid' => $result->id_str]);
 834                         Item::update(['extid' => "twitter::" . $result->id_str], ['id' => $b['id']]);
 835                 }
 836         }
 837 }
 838
 839 function twitter_delete_item(array $item)
 840 {
 841         if (!$item['deleted']) {
 842                 return;
 843         }
 844
 845         if ($item['parent'] != $item['id']) {
 846                 Logger::debug('Deleting comment/announce', ['item' => $item]);
 847
 848                 // Looking if it's a reply to a twitter post
 849                 if (!twitter_get_id($item['parent-uri']) &&
 850                         !twitter_get_id($item['extid']) &&
 851                         !twitter_get_id($item['thr-parent'])) {
 852                         Logger::info('No twitter post', ['parent' => $item['parent']]);
 853                         return;
 854                 }
 855
 856                 $condition = ['uri' => $item['thr-parent'], 'uid' => $item['uid']];
 857                 $thr_parent = Post::selectFirst(['uri', 'extid', 'author-link', 'author-nick', 'author-network'], $condition);
 858                 if (!DBA::isResult($thr_parent)) {
 859                         Logger::warning('No parent found', ['thr-parent' => $item['thr-parent']]);
 860                         return;
 861                 }
 862
 863                 Logger::debug('Parent found', ['parent' => $thr_parent]);
 864         } else {
 865                 if (!strstr($item['extid'], 'twitter')) {
 866                         DI::logger()->info('Not a Twitter post', ['extid' => $item['extid']]);
 867                         return;
 868                 }
 869
 870                 // Don't delete if the post doesn't belong to us.
 871                 // This is a check for forum postings
 872                 $self = DBA::selectFirst('contact', ['id'], ['uid' => $item['uid'], 'self' => true]);
 873                 if ($item['contact-id'] != $self['id']) {
 874                         DI::logger()->info('Don\'t delete if the post doesn\'t belong to the user', ['contact-id' => $item['contact-id'], 'self' => $self['id']]);
 875                         return;
 876                 }
 877         }
 878
 879         /**
 880          * @TODO Remaining caveat: Comments posted on Twitter and imported in Friendica do not trigger any Notifier task,
 881          *       possibly because they are private to the user and don't require any remote deletion notifications sent.
 882          *       Comments posted on Friendica and mirrored on Twitter trigger the Notifier task and the Twitter counter-part
 883          *       will be deleted accordingly.
 884          */
 885         if ($item['verb'] == Activity::POST) {
 886                 Logger::info('Delete post/comment', ['uid' => $item['uid'], 'id' => twitter_get_id($item['extid'])]);
 887                 twitter_api_post('statuses/destroy', twitter_get_id($item['extid']), $item['uid']);
 888                 return;
 889         }
 890
 891         if ($item['verb'] == Activity::LIKE) {
 892                 Logger::info('Unlike', ['uid' => $item['uid'], 'id' => twitter_get_id($item['thr-parent'])]);
 893                 twitter_api_post('favorites/destroy', twitter_get_id($item['thr-parent']), $item['uid']);
 894                 return;
 895         }
 896
 897         if ($item['verb'] == Activity::ANNOUNCE && !empty($thr_parent['uri'])) {
 898                 Logger::info('Unretweet', ['uid' => $item['uid'], 'extid' => $thr_parent['uri'], 'id' => twitter_get_id($thr_parent['uri'])]);
 899                 twitter_api_post('statuses/unretweet', twitter_get_id($thr_parent['uri']), $item['uid']);
 900                 return;
 901         }
 902 }
 903
 904 function twitter_addon_admin_post(App $a)
 905 {
 906         $consumerkey    = trim($_POST['consumerkey'] ?? '');
 907         $consumersecret = trim($_POST['consumersecret'] ?? '');
 908         DI::config()->set('twitter', 'consumerkey', $consumerkey);
 909         DI::config()->set('twitter', 'consumersecret', $consumersecret);
 910 }
 911
 912 function twitter_addon_admin(App $a, &$o)
 913 {
 914         $t = Renderer::getMarkupTemplate("admin.tpl", "addon/twitter/");
 915
 916         $o = Renderer::replaceMacros($t, [
 917                 '$submit' => DI::l10n()->t('Save Settings'),
 918                 // name, label, value, help, [extra values]
 919                 '$consumerkey' => ['consumerkey', DI::l10n()->t('Consumer key'), DI::config()->get('twitter', 'consumerkey'), ''],
 920                 '$consumersecret' => ['consumersecret', DI::l10n()->t('Consumer secret'), DI::config()->get('twitter', 'consumersecret'), ''],
 921         ]);
 922 }
 923
 924 function twitter_cron(App $a)
 925 {
 926         $last = DI::config()->get('twitter', 'last_poll');
 927
 928         $poll_interval = intval(DI::config()->get('twitter', 'poll_interval'));
 929         if (!$poll_interval) {
 930                 $poll_interval = TWITTER_DEFAULT_POLL_INTERVAL;
 931         }
 932
 933         if ($last) {
 934                 $next = $last + ($poll_interval * 60);
 935                 if ($next > time()) {
 936                         Logger::notice('twitter: poll intervall not reached');
 937                         return;
 938                 }
 939         }
 940         Logger::notice('twitter: cron_start');
 941
 942         $pconfigs = DBA::selectToArray('pconfig', [], ['cat' => 'twitter', 'k' => 'mirror_posts', 'v' => true]);
 943         foreach ($pconfigs as $rr) {
 944                 Logger::notice('Fetching', ['user' => $rr['uid']]);
 945                 Worker::add(['priority' => PRIORITY_MEDIUM, 'force_priority' => true], "addon/twitter/twitter_sync.php", 1, (int) $rr['uid']);
 946         }
 947
 948         $abandon_days = intval(DI::config()->get('system', 'account_abandon_days'));
 949         if ($abandon_days < 1) {
 950                 $abandon_days = 0;
 951         }
 952
 953         $abandon_limit = date(DateTimeFormat::MYSQL, time() - $abandon_days * 86400);
 954
 955         $pconfigs = DBA::selectToArray('pconfig', [], ['cat' => 'twitter', 'k' => 'import', 'v' => true]);
 956         foreach ($pconfigs as $rr) {
 957                 if ($abandon_days != 0) {
 958                         if (!DBA::exists('user', ["`uid` = ? AND `login_date` >= ?", $rr['uid'], $abandon_limit])) {
 959                                 Logger::notice('abandoned account: timeline from user will not be imported', ['user' => $rr['uid']]);
 960                                 continue;
 961                         }
 962                 }
 963
 964                 Logger::notice('importing timeline', ['user' => $rr['uid']]);
 965                 Worker::add(['priority' => PRIORITY_MEDIUM, 'force_priority' => true], "addon/twitter/twitter_sync.php", 2, (int) $rr['uid']);
 966                 /*
 967                         // To-Do
 968                         // check for new contacts once a day
 969                         $last_contact_check = DI::pConfig()->get($rr['uid'],'pumpio','contact_check');
 970                         if($last_contact_check)
 971                         $next_contact_check = $last_contact_check + 86400;
 972                         else
 973                         $next_contact_check = 0;
 974
 975                         if($next_contact_check <= time()) {
 976                         pumpio_getallusers($a, $rr["uid"]);
 977                         DI::pConfig()->set($rr['uid'],'pumpio','contact_check',time());
 978                         }
 979                         */
 980         }
 981
 982         Logger::notice('twitter: cron_end');
 983
 984         DI::config()->set('twitter', 'last_poll', time());
 985 }
 986
 987 function twitter_expire(App $a)
 988 {
 989         $days = DI::config()->get('twitter', 'expire');
 990
 991         if ($days == 0) {
 992                 return;
 993         }
 994
 995         Logger::notice('Start deleting expired posts');
 996
 997         $r = Post::select(['id', 'guid'], ['deleted' => true, 'network' => Protocol::TWITTER]);
 998         while ($row = Post::fetch($r)) {
 999                 Logger::info('[twitter] Delete expired item', ['id' => $row['id'], 'guid' => $row['guid'], 'callstack' => \Friendica\Core\System::callstack()]);
1000                 Item::markForDeletionById($row['id']);
1001         }
1002         DBA::close($r);
1003
1004         Logger::notice('End deleting expired posts');
1005
1006         Logger::notice('Start expiry');
1007
1008         $pconfigs = DBA::selectToArray('pconfig', [], ['cat' => 'twitter', 'k' => 'import', 'v' => true]);
1009         foreach ($pconfigs as $rr) {
1010                 Logger::notice('twitter_expire', ['user' => $rr['uid']]);
1011                 Item::expire($rr['uid'], $days, Protocol::TWITTER, true);
1012         }
1013
1014         Logger::notice('End expiry');
1015 }
1016
1017 function twitter_prepare_body(App $a, array &$b)
1018 {
1019         if ($b["item"]["network"] != Protocol::TWITTER) {
1020                 return;
1021         }
1022
1023         if ($b["preview"]) {
1024                 $max_char = 280;
1025                 $item = $b["item"];
1026                 $item["plink"] = DI::baseUrl()->get() . "/display/" . $item["guid"];
1027
1028                 $condition = ['uri' => $item["thr-parent"], 'uid' => local_user()];
1029                 $orig_post = Post::selectFirst(['author-link'], $condition);
1030                 if (DBA::isResult($orig_post)) {
1031                         $nicknameplain = preg_replace("=https?://twitter.com/(.*)=ism", "$1", $orig_post["author-link"]);
1032                         $nickname = "@[url=" . $orig_post["author-link"] . "]" . $nicknameplain . "[/url]";
1033                         $nicknameplain = "@" . $nicknameplain;
1034
1035                         if ((strpos($item["body"], $nickname) === false) && (strpos($item["body"], $nicknameplain) === false)) {
1036                                 $item["body"] = $nickname . " " . $item["body"];
1037                         }
1038                 }
1039
1040                 $msgarr = Plaintext::getPost($item, $max_char, true, BBCode::TWITTER);
1041                 $msg = $msgarr["text"];
1042
1043                 if (isset($msgarr["url"]) && ($msgarr["type"] != "photo")) {
1044                         $msg .= " " . $msgarr["url"];
1045                 }
1046
1047                 if (isset($msgarr["image"])) {
1048                         $msg .= " " . $msgarr["image"];
1049                 }
1050
1051                 $b['html'] = nl2br(htmlspecialchars($msg));
1052         }
1053 }
1054
1055 function twitter_statuses_show(string $id, TwitterOAuth $twitterOAuth = null)
1056 {
1057         if ($twitterOAuth === null) {
1058                 $ckey = DI::config()->get('twitter', 'consumerkey');
1059                 $csecret = DI::config()->get('twitter', 'consumersecret');
1060
1061                 if (empty($ckey) || empty($csecret)) {
1062                         return new stdClass();
1063                 }
1064
1065                 $twitterOAuth = new TwitterOAuth($ckey, $csecret);
1066         }
1067
1068         $parameters = ['trim_user' => false, 'tweet_mode' => 'extended', 'id' => $id, 'include_ext_alt_text' => true];
1069
1070         return $twitterOAuth->get('statuses/show', $parameters);
1071 }
1072
1073 /**
1074  * Parse Twitter status URLs since Twitter removed OEmbed
1075  *
1076  * @param App   $a
1077  * @param array $b Expected format:
1078  *                 [
1079  *                      'url' => [URL to parse],
1080  *                      'format' => 'json'|'',
1081  *                      'text' => Output parameter
1082  *                 ]
1083  * @throws \Friendica\Network\HTTPException\InternalServerErrorException
1084  */
1085 function twitter_parse_link(App $a, array &$b)
1086 {
1087         // Only handle Twitter status URLs
1088         if (!preg_match('#^https?://(?:mobile\.|www\.)?twitter.com/[^/]+/status/(\d+).*#', $b['url'], $matches)) {
1089                 return;
1090         }
1091
1092         $status = twitter_statuses_show($matches[1]);
1093
1094         if (empty($status->id)) {
1095                 return;
1096         }
1097
1098         $item = twitter_createpost($a, 0, $status, [], true, false, true);
1099
1100         if ($b['format'] == 'json') {
1101                 $images = [];
1102                 foreach ($status->extended_entities->media ?? [] as $media) {
1103                         if (!empty($media->media_url_https)) {
1104                                 $images[] = [
1105                                         'src'    => $media->media_url_https,
1106                                         'width'  => $media->sizes->thumb->w,
1107                                         'height' => $media->sizes->thumb->h,
1108                                 ];
1109                         }
1110                 }
1111
1112                 $b['text'] = [
1113                         'data' => [
1114                                 'type' => 'link',
1115                                 'url' => $item['plink'],
1116                                 'title' => DI::l10n()->t('%s on Twitter', $status->user->name),
1117                                 'text' => BBCode::toPlaintext($item['body'], false),
1118                                 'images' => $images,
1119                         ],
1120                         'contentType' => 'attachment',
1121                         'success' => true,
1122                 ];
1123         } else {
1124                 $b['text'] = BBCode::getShareOpeningTag(
1125                         $item['author-name'],
1126                         $item['author-link'],
1127                         $item['author-avatar'],
1128                         $item['plink'],
1129                         $item['created']
1130                 );
1131                 $b['text'] .= $item['body'] . '[/share]';
1132         }
1133 }
1134
1135
1136 /*********************
1137  *
1138  * General functions
1139  *
1140  *********************/
1141
1142
1143 /**
1144  * @brief Build the item array for the mirrored post
1145  *
1146  * @param App $a Application class
1147  * @param integer $uid User id
1148  * @param object $post Twitter object with the post
1149  *
1150  * @return array item data to be posted
1151  */
1152 function twitter_do_mirrorpost(App $a, $uid, $post)
1153 {
1154         $datarray['uid'] = $uid;
1155         $datarray['extid'] = 'twitter::' . $post->id;
1156         $datarray['title'] = '';
1157
1158         if (!empty($post->retweeted_status)) {
1159                 // We don't support nested shares, so we mustn't show quotes as shares on retweets
1160                 $item = twitter_createpost($a, $uid, $post->retweeted_status, ['id' => 0], false, false, true, -1);
1161
1162                 if (empty($item['body'])) {
1163                         return [];
1164                 }
1165
1166                 $datarray['body'] = "\n" . BBCode::getShareOpeningTag(
1167                         $item['author-name'],
1168                         $item['author-link'],
1169                         $item['author-avatar'],
1170                         $item['plink'],
1171                         $item['created']
1172                 );
1173
1174                 $datarray['body'] .= $item['body'] . '[/share]';
1175         } else {
1176                 $item = twitter_createpost($a, $uid, $post, ['id' => 0], false, false, false, -1);
1177
1178                 if (empty($item['body'])) {
1179                         return [];
1180                 }
1181
1182                 $datarray['body'] = $item['body'];
1183         }
1184
1185         $datarray['app'] = $item['app'];
1186         $datarray['verb'] = $item['verb'];
1187
1188         if (isset($item['location'])) {
1189                 $datarray['location'] = $item['location'];
1190         }
1191
1192         if (isset($item['coord'])) {
1193                 $datarray['coord'] = $item['coord'];
1194         }
1195
1196         return $datarray;
1197 }
1198
1199 function twitter_fetchtimeline(App $a, $uid)
1200 {
1201         $ckey    = DI::config()->get('twitter', 'consumerkey');
1202         $csecret = DI::config()->get('twitter', 'consumersecret');
1203         $otoken  = DI::pConfig()->get($uid, 'twitter', 'oauthtoken');
1204         $osecret = DI::pConfig()->get($uid, 'twitter', 'oauthsecret');
1205         $lastid  = DI::pConfig()->get($uid, 'twitter', 'lastid');
1206
1207         $application_name = DI::config()->get('twitter', 'application_name');
1208
1209         if ($application_name == "") {
1210                 $application_name = DI::baseUrl()->getHostname();
1211         }
1212
1213         $connection = new TwitterOAuth($ckey, $csecret, $otoken, $osecret);
1214
1215         // Ensure to have the own contact
1216         try {
1217                 twitter_fetch_own_contact($a, $uid);
1218         } catch (TwitterOAuthException $e) {
1219                 Logger::warning('Error fetching own contact', ['uid' => $uid, 'message' => $e->getMessage()]);
1220                 return;
1221         }
1222
1223         $parameters = ["exclude_replies" => true, "trim_user" => false, "contributor_details" => true, "include_rts" => true, "tweet_mode" => "extended", "include_ext_alt_text" => true];
1224
1225         $first_time = ($lastid == "");
1226
1227         if ($lastid != "") {
1228                 $parameters["since_id"] = $lastid;
1229         }
1230
1231         try {
1232                 $items = $connection->get('statuses/user_timeline', $parameters);
1233         } catch (TwitterOAuthException $e) {
1234                 Logger::warning('Error fetching timeline', ['uid' => $uid, 'message' => $e->getMessage()]);
1235                 return;
1236         }
1237
1238         if (!is_array($items)) {
1239                 Logger::notice('No items', ['user' => $uid]);
1240                 return;
1241         }
1242
1243         $posts = array_reverse($items);
1244
1245         Logger::notice('Start processing posts', ['from' => $lastid, 'user' => $uid, 'count' => count($posts)]);
1246
1247         if (count($posts)) {
1248                 foreach ($posts as $post) {
1249                         if ($post->id_str > $lastid) {
1250                                 $lastid = $post->id_str;
1251                                 DI::pConfig()->set($uid, 'twitter', 'lastid', $lastid);
1252                         }
1253
1254                         if ($first_time) {
1255                                 continue;
1256                         }
1257
1258                         if (!stristr($post->source, $application_name)) {
1259                                 Logger::info('Preparing mirror post', ['twitter-id' => $post->id_str, 'uid' => $uid]);
1260
1261                                 $mirrorpost = twitter_do_mirrorpost($a, $uid, $post);
1262
1263                                 if (empty($mirrorpost['body'])) {
1264                                         continue;
1265                                 }
1266
1267                                 Logger::info('Posting mirror post', ['twitter-id' => $post->id_str, 'uid' => $uid]);
1268
1269                                 Post\Delayed::add($mirrorpost['extid'], $mirrorpost, PRIORITY_MEDIUM, Post\Delayed::UNPREPARED);
1270                         }
1271                 }
1272         }
1273         DI::pConfig()->set($uid, 'twitter', 'lastid', $lastid);
1274         Logger::info('Last ID for user ' . $uid . ' is now ' . $lastid);
1275 }
1276
1277 function twitter_fix_avatar($avatar)
1278 {
1279         $new_avatar = str_replace("_normal.", "_400x400.", $avatar);
1280
1281         $info = Images::getInfoFromURLCached($new_avatar);
1282         if (!$info) {
1283                 $new_avatar = $avatar;
1284         }
1285
1286         return $new_avatar;
1287 }
1288
1289 function twitter_get_relation($uid, $target, $contact = [])
1290 {
1291         if (isset($contact['rel'])) {
1292                 $relation = $contact['rel'];
1293         } else {
1294                 $relation = 0;
1295         }
1296
1297         $ckey = DI::config()->get('twitter', 'consumerkey');
1298         $csecret = DI::config()->get('twitter', 'consumersecret');
1299         $otoken = DI::pConfig()->get($uid, 'twitter', 'oauthtoken');
1300         $osecret = DI::pConfig()->get($uid, 'twitter', 'oauthsecret');
1301         $own_id = DI::pConfig()->get($uid, 'twitter', 'own_id');
1302
1303         $connection = new TwitterOAuth($ckey, $csecret, $otoken, $osecret);
1304         $parameters = ['source_id' => $own_id, 'target_screen_name' => $target];
1305
1306         try {
1307                 $status = $connection->get('friendships/show', $parameters);
1308                 if ($connection->getLastHttpCode() !== 200) {
1309                         throw new Exception($status->errors[0]->message ?? 'HTTP response code ' . $connection->getLastHttpCode(), $status->errors[0]->code ?? $connection->getLastHttpCode());
1310                 }
1311
1312                 $following = $status->relationship->source->following;
1313                 $followed = $status->relationship->source->followed_by;
1314
1315                 if ($following && !$followed) {
1316                         $relation = Contact::SHARING;
1317                 } elseif (!$following && $followed) {
1318                         $relation = Contact::FOLLOWER;
1319                 } elseif ($following && $followed) {
1320                         $relation = Contact::FRIEND;
1321                 } elseif (!$following && !$followed) {
1322                         $relation = 0;
1323                 }
1324
1325                 Logger::info('Fetched friendship relation', ['user' => $uid, 'target' => $target, 'relation' => $relation]);
1326         } catch (Throwable $e) {
1327                 Logger::warning('Error fetching friendship status', ['uid' => $uid, 'target' => $target, 'message' => $e->getMessage()]);
1328         }
1329
1330         return $relation;
1331 }
1332
1333 /**
1334  * @param $data
1335  * @return array
1336  */
1337 function twitter_user_to_contact($data)
1338 {
1339         if (empty($data->id_str)) {
1340                 return [];
1341         }
1342
1343         $baseurl = 'https://twitter.com';
1344         $url = $baseurl . '/' . $data->screen_name;
1345         $addr = $data->screen_name . '@twitter.com';
1346
1347         $fields = [
1348                 'url'      => $url,
1349                 'nurl'     => Strings::normaliseLink($url),
1350                 'uri-id'   => ItemURI::getIdByURI($url),
1351                 'network'  => Protocol::TWITTER,
1352                 'alias'    => 'twitter::' . $data->id_str,
1353                 'baseurl'  => $baseurl,
1354                 'name'     => $data->name,
1355                 'nick'     => $data->screen_name,
1356                 'addr'     => $addr,
1357                 'location' => $data->location,
1358                 'about'    => $data->description,
1359                 'photo'    => twitter_fix_avatar($data->profile_image_url_https),
1360                 'header'   => $data->profile_banner_url ?? $data->profile_background_image_url_https,
1361         ];
1362
1363         return $fields;
1364 }
1365
1366 function twitter_get_contact($data, int $uid = 0)
1367 {
1368         $contact = DBA::selectFirst('contact', ['id'], ['uid' => $uid, 'alias' => "twitter::" . $data->id_str]);
1369         if (DBA::isResult($contact)) {
1370                 return $contact['id'];
1371         } else {
1372                 return twitter_fetch_contact($uid, $data, false);
1373         }
1374 }
1375
1376 function twitter_fetch_contact($uid, $data, $create_user)
1377 {
1378         $fields = twitter_user_to_contact($data);
1379
1380         if (empty($fields)) {
1381                 return -1;
1382         }
1383
1384         // photo comes from twitter_user_to_contact but shouldn't be saved directly in the contact row
1385         $avatar = $fields['photo'];
1386         unset($fields['photo']);
1387
1388         // Update the public contact
1389         $pcontact = DBA::selectFirst('contact', ['id'], ['uid' => 0, 'alias' => "twitter::" . $data->id_str]);
1390         if (DBA::isResult($pcontact)) {
1391                 $cid = $pcontact['id'];
1392         } else {
1393                 $cid = Contact::getIdForURL($fields['url'], 0, false, $fields);
1394         }
1395
1396         if (!empty($cid)) {
1397                 Contact::update($fields, ['id' => $cid]);
1398                 Contact::updateAvatar($cid, $avatar);
1399         } else {
1400                 Logger::warning('No contact found', ['fields' => $fields]);
1401         }
1402
1403         $contact = DBA::selectFirst('contact', [], ['uid' => $uid, 'alias' => "twitter::" . $data->id_str]);
1404         if (!DBA::isResult($contact) && empty($cid)) {
1405                 Logger::warning('User contact not found', ['uid' => $uid, 'twitter-id' => $data->id_str]);
1406                 return 0;
1407         } elseif (!$create_user) {
1408                 return $cid;
1409         }
1410
1411         if (!DBA::isResult($contact)) {
1412                 $relation = twitter_get_relation($uid, $data->screen_name);
1413
1414                 // create contact record
1415                 $fields['uid'] = $uid;
1416                 $fields['created'] = DateTimeFormat::utcNow();
1417                 $fields['poll'] = 'twitter::' . $data->id_str;
1418                 $fields['rel'] = $relation;
1419                 $fields['priority'] = 1;
1420                 $fields['writable'] = true;
1421                 $fields['blocked'] = false;
1422                 $fields['readonly'] = false;
1423                 $fields['pending'] = false;
1424
1425                 if (!Contact::insert($fields)) {
1426                         return false;
1427                 }
1428
1429                 $contact_id = DBA::lastInsertId();
1430
1431                 Group::addMember(User::getDefaultGroup($uid), $contact_id);
1432         } else {
1433                 if ($contact["readonly"] || $contact["blocked"]) {
1434                         Logger::notice('Contact is blocked or readonly.', ['nickname' => $contact["nick"]]);
1435                         return -1;
1436                 }
1437
1438                 $contact_id = $contact['id'];
1439                 $update = false;
1440
1441                 // Update the contact relation once per day
1442                 if ($contact['updated'] < DateTimeFormat::utc('now -24 hours')) {
1443                         $fields['rel'] = twitter_get_relation($uid, $data->screen_name, $contact);
1444                         $update = true;
1445                 }
1446
1447                 if ($contact['name'] != $data->name) {
1448                         $fields['name-date'] = $fields['uri-date'] = DateTimeFormat::utcNow();
1449                         $update = true;
1450                 }
1451
1452                 if ($contact['nick'] != $data->screen_name) {
1453                         $fields['uri-date'] = DateTimeFormat::utcNow();
1454                         $update = true;
1455                 }
1456
1457                 if (($contact['location'] != $data->location) || ($contact['about'] != $data->description)) {
1458                         $update = true;
1459                 }
1460
1461                 if ($update) {
1462                         $fields['updated'] = DateTimeFormat::utcNow();
1463                         Contact::update($fields, ['id' => $contact['id']]);
1464                         Logger::info('Updated contact', ['id' => $contact['id'], 'nick' => $data->screen_name]);
1465                 }
1466         }
1467
1468         Contact::updateAvatar($contact_id, $avatar);
1469
1470         return $contact_id;
1471 }
1472
1473 /**
1474  * @param string $screen_name
1475  * @return stdClass|null
1476  * @throws Exception
1477  */
1478 function twitter_fetchuser($screen_name)
1479 {
1480         $ckey = DI::config()->get('twitter', 'consumerkey');
1481         $csecret = DI::config()->get('twitter', 'consumersecret');
1482
1483         try {
1484                 // Fetching user data
1485                 $connection = new TwitterOAuth($ckey, $csecret);
1486                 $parameters = ['screen_name' => $screen_name];
1487                 $user = $connection->get('users/show', $parameters);
1488         } catch (TwitterOAuthException $e) {
1489                 Logger::warning('Error fetching user', ['user' => $screen_name, 'message' => $e->getMessage()]);
1490                 return null;
1491         }
1492
1493         if (!is_object($user)) {
1494                 return null;
1495         }
1496
1497         return $user;
1498 }
1499
1500 /**
1501  * Replaces Twitter entities with Friendica-friendly links.
1502  *
1503  * The Twitter API gives indices for each entity, which allows for fine-grained replacement.
1504  *
1505  * First, we need to collect everything that needs to be replaced, what we will replace it with, and the start index.
1506  * Then we sort the indices decreasingly, and we replace from the end of the body to the start in order for the next
1507  * index to be correct even after the last replacement.
1508  *
1509  * @param string   $body
1510  * @param stdClass $status
1511  * @return array
1512  * @throws \Friendica\Network\HTTPException\InternalServerErrorException
1513  */
1514 function twitter_expand_entities($body, stdClass $status)
1515 {
1516         $plain = $body;
1517         $contains_urls = false;
1518
1519         $taglist = [];
1520
1521         $replacementList = [];
1522
1523         foreach ($status->entities->hashtags AS $hashtag) {
1524                 $replace = '#[url=' . DI::baseUrl()->get() . '/search?tag=' . $hashtag->text . ']' . $hashtag->text . '[/url]';
1525                 $taglist['#' . $hashtag->text] = ['#', $hashtag->text, ''];
1526
1527                 $replacementList[$hashtag->indices[0]] = [
1528                         'replace' => $replace,
1529                         'length' => $hashtag->indices[1] - $hashtag->indices[0],
1530                 ];
1531         }
1532
1533         foreach ($status->entities->user_mentions AS $mention) {
1534                 $replace = '@[url=https://twitter.com/' . rawurlencode($mention->screen_name) . ']' . $mention->screen_name . '[/url]';
1535                 $taglist['@' . $mention->screen_name] = ['@', $mention->screen_name, 'https://twitter.com/' . rawurlencode($mention->screen_name)];
1536
1537                 $replacementList[$mention->indices[0]] = [
1538                         'replace' => $replace,
1539                         'length' => $mention->indices[1] - $mention->indices[0],
1540                 ];
1541         }
1542
1543         foreach ($status->entities->urls ?? [] as $url) {
1544                 $plain = str_replace($url->url, '', $plain);
1545
1546                 if ($url->url && $url->expanded_url && $url->display_url) {
1547                         // Quote tweet, we just remove the quoted tweet URL from the body, the share block will be added later.
1548                         if (!empty($status->quoted_status) && isset($status->quoted_status_id_str)
1549                                 && substr($url->expanded_url, -strlen($status->quoted_status_id_str)) == $status->quoted_status_id_str
1550                         ) {
1551                                 $replacementList[$url->indices[0]] = [
1552                                         'replace' => '',
1553                                         'length' => $url->indices[1] - $url->indices[0],
1554                                 ];
1555                                 continue;
1556                         }
1557
1558                         $contains_urls = true;
1559
1560                         $expanded_url = $url->expanded_url;
1561
1562                         // Quickfix: Workaround for URL with '[' and ']' in it
1563                         if (strpos($expanded_url, '[') || strpos($expanded_url, ']')) {
1564                                 $expanded_url = $url->url;
1565                         }
1566
1567                         $replacementList[$url->indices[0]] = [
1568                                 'replace' => '[url=' . $expanded_url . ']' . $url->display_url . '[/url]',
1569                                 'length' => $url->indices[1] - $url->indices[0],
1570                         ];
1571                 }
1572         }
1573
1574         krsort($replacementList);
1575
1576         foreach ($replacementList as $startIndex => $parameters) {
1577                 $body = Strings::substringReplace($body, $parameters['replace'], $startIndex, $parameters['length']);
1578         }
1579
1580         $body = trim($body);
1581
1582         return ['body' => trim($body), 'plain' => trim($plain), 'taglist' => $taglist, 'urls' => $contains_urls];
1583 }
1584
1585 /**
1586  * Store entity attachments
1587  *
1588  * @param integer $uriid
1589  * @param object $post Twitter object with the post
1590  */
1591 function twitter_store_attachments(int $uriid, $post)
1592 {
1593         if (!empty($post->extended_entities->media)) {
1594                 foreach ($post->extended_entities->media AS $medium) {
1595                         switch ($medium->type) {
1596                                 case 'photo':
1597                                         $attachment = ['uri-id' => $uriid, 'type' => Post\Media::IMAGE];
1598
1599                                         $attachment['url'] = $medium->media_url_https . '?name=large';
1600                                         $attachment['width'] = $medium->sizes->large->w;
1601                                         $attachment['height'] = $medium->sizes->large->h;
1602
1603                                         if ($medium->sizes->small->w != $attachment['width']) {
1604                                                 $attachment['preview'] = $medium->media_url_https . '?name=small';
1605                                                 $attachment['preview-width'] = $medium->sizes->small->w;
1606                                                 $attachment['preview-height'] = $medium->sizes->small->h;
1607                                         }
1608
1609                                         $attachment['name'] = $medium->display_url ?? null;
1610                                         $attachment['description'] = $medium->ext_alt_text ?? null;
1611                                         Logger::debug('Photo attachment', ['attachment' => $attachment]);
1612                                         Post\Media::insert($attachment);
1613                                         break;
1614                                 case 'video':
1615                                 case 'animated_gif':
1616                                         $attachment = ['uri-id' => $uriid, 'type' => Post\Media::VIDEO];
1617                                         if (is_array($medium->video_info->variants)) {
1618                                                 $bitrate = 0;
1619                                                 // We take the video with the highest bitrate
1620                                                 foreach ($medium->video_info->variants AS $variant) {
1621                                                         if (($variant->content_type == 'video/mp4') && ($variant->bitrate >= $bitrate)) {
1622                                                                 $attachment['url'] = $variant->url;
1623                                                                 $bitrate = $variant->bitrate;
1624                                                         }
1625                                                 }
1626                                         }
1627
1628                                         $attachment['name'] = $medium->display_url ?? null;
1629                                         $attachment['preview'] = $medium->media_url_https . ':small';
1630                                         $attachment['preview-width'] = $medium->sizes->small->w;
1631                                         $attachment['preview-height'] = $medium->sizes->small->h;
1632                                         $attachment['description'] = $medium->ext_alt_text ?? null;
1633                                         Logger::debug('Video attachment', ['attachment' => $attachment]);
1634                                         Post\Media::insert($attachment);
1635                                         break;
1636                                 default:
1637                                         Logger::notice('Unknown media type', ['medium' => $medium]);
1638                         }
1639                 }
1640         }
1641
1642         if (!empty($post->entities->urls)) {
1643                 foreach ($post->entities->urls as $url) {
1644                         $attachment = ['uri-id' => $uriid, 'type' => Post\Media::UNKNOWN, 'url' => $url->expanded_url, 'name' => $url->display_url];
1645                         Logger::debug('Attached link', ['attachment' => $attachment]);
1646                         Post\Media::insert($attachment);
1647                 }
1648         }
1649 }
1650
1651 /**
1652  * @brief Fetch media entities and add media links to the body
1653  *
1654  * @param object  $post      Twitter object with the post
1655  * @param array   $postarray Array of the item that is about to be posted
1656  * @param integer $uriid URI Id used to store tags. -1 = don't store tags for this post.
1657  */
1658 function twitter_media_entities($post, array &$postarray, int $uriid = -1)
1659 {
1660         // There are no media entities? So we quit.
1661         if (empty($post->extended_entities->media)) {
1662                 return;
1663         }
1664
1665         // This is a pure media post, first search for all media urls
1666         $media = [];
1667         foreach ($post->extended_entities->media AS $medium) {
1668                 if (!isset($media[$medium->url])) {
1669                         $media[$medium->url] = '';
1670                 }
1671                 switch ($medium->type) {
1672                         case 'photo':
1673                                 if (!empty($medium->ext_alt_text)) {
1674                                         Logger::info('Got text description', ['alt_text' => $medium->ext_alt_text]);
1675                                         $media[$medium->url] .= "\n[img=" . $medium->media_url_https .']' . $medium->ext_alt_text . '[/img]';
1676                                 } else {
1677                                         $media[$medium->url] .= "\n[img]" . $medium->media_url_https . '[/img]';
1678                                 }
1679
1680                                 $postarray['object-type'] = Activity\ObjectType::IMAGE;
1681                                 $postarray['post-type'] = Item::PT_IMAGE;
1682                                 break;
1683                         case 'video':
1684                                 // Currently deactivated, since this causes the video to be display before the content
1685                                 // We have to figure out a better way for declaring the post type and the display style.
1686                                 //$postarray['post-type'] = Item::PT_VIDEO;
1687                         case 'animated_gif':
1688                                 if (!empty($medium->ext_alt_text)) {
1689                                         Logger::info('Got text description', ['alt_text' => $medium->ext_alt_text]);
1690                                         $media[$medium->url] .= "\n[img=" . $medium->media_url_https .']' . $medium->ext_alt_text . '[/img]';
1691                                 } else {
1692                                         $media[$medium->url] .= "\n[img]" . $medium->media_url_https . '[/img]';
1693                                 }
1694
1695                                 $postarray['object-type'] = Activity\ObjectType::VIDEO;
1696                                 if (is_array($medium->video_info->variants)) {
1697                                         $bitrate = 0;
1698                                         // We take the video with the highest bitrate
1699                                         foreach ($medium->video_info->variants AS $variant) {
1700                                                 if (($variant->content_type == 'video/mp4') && ($variant->bitrate >= $bitrate)) {
1701                                                         $media[$medium->url] = "\n[video]" . $variant->url . '[/video]';
1702                                                         $bitrate = $variant->bitrate;
1703                                                 }
1704                                         }
1705                                 }
1706                                 break;
1707                 }
1708         }
1709
1710         if ($uriid != -1) {
1711                 foreach ($media AS $key => $value) {
1712                         $postarray['body'] = str_replace($key, '', $postarray['body']);
1713                 }
1714                 return;
1715         }
1716
1717         // Now we replace the media urls.
1718         foreach ($media AS $key => $value) {
1719                 $postarray['body'] = str_replace($key, "\n" . $value . "\n", $postarray['body']);
1720         }
1721 }
1722
1723 /**
1724  * Undocumented function
1725  *
1726  * @param App $a
1727  * @param integer $uid User ID
1728  * @param object $post Incoming Twitter post
1729  * @param array $self
1730  * @param bool $create_user Should users be created?
1731  * @param bool $only_existing_contact Only import existing contacts if set to "true"
1732  * @param bool $noquote
1733  * @param integer $uriid URI Id used to store tags. 0 = create a new one; -1 = don't store tags for this post.
1734  * @return array item array
1735  */
1736 function twitter_createpost(App $a, $uid, $post, array $self, $create_user, $only_existing_contact, $noquote, int $uriid = 0)
1737 {
1738         $postarray = [];
1739         $postarray['network'] = Protocol::TWITTER;
1740         $postarray['uid'] = $uid;
1741         $postarray['wall'] = 0;
1742         $postarray['uri'] = "twitter::" . $post->id_str;
1743         $postarray['protocol'] = Conversation::PARCEL_TWITTER;
1744         $postarray['source'] = json_encode($post);
1745         $postarray['direction'] = Conversation::PULL;
1746
1747         if (empty($uriid)) {
1748                 $uriid = $postarray['uri-id'] = ItemURI::insert(['uri' => $postarray['uri']]);
1749         }
1750
1751         // Don't import our own comments
1752         if (Post::exists(['extid' => $postarray['uri'], 'uid' => $uid])) {
1753                 Logger::info('Item found', ['extid' => $postarray['uri']]);
1754                 return [];
1755         }
1756
1757         $contactid = 0;
1758
1759         if ($post->in_reply_to_status_id_str != "") {
1760                 $thr_parent = "twitter::" . $post->in_reply_to_status_id_str;
1761
1762                 $item = Post::selectFirst(['uri'], ['uri' => $thr_parent, 'uid' => $uid]);
1763                 if (!DBA::isResult($item)) {
1764                         $item = Post::selectFirst(['uri'], ['extid' => $thr_parent, 'uid' => $uid]);
1765                 }
1766
1767                 if (DBA::isResult($item)) {
1768                         $postarray['thr-parent'] = $item['uri'];
1769                         $postarray['object-type'] = Activity\ObjectType::COMMENT;
1770                 } else {
1771                         $postarray['object-type'] = Activity\ObjectType::NOTE;
1772                 }
1773
1774                 // Is it me?
1775                 $own_id = DI::pConfig()->get($uid, 'twitter', 'own_id');
1776
1777                 if ($post->user->id_str == $own_id) {
1778                         $self = Contact::selectFirst(['id', 'name', 'url', 'photo'], ['self' => true, 'uid' => $uid]);
1779                         if (DBA::isResult($self)) {
1780                                 $contactid = $self['id'];
1781
1782                                 $postarray['owner-name']   = $self['name'];
1783                                 $postarray['owner-link']   = $self['url'];
1784                                 $postarray['owner-avatar'] = $self['photo'];
1785                         } else {
1786                                 Logger::error('No self contact found', ['uid' => $uid]);
1787                                 return [];
1788                         }
1789                 }
1790                 // Don't create accounts of people who just comment something
1791                 $create_user = false;
1792         } else {
1793                 $postarray['object-type'] = Activity\ObjectType::NOTE;
1794         }
1795
1796         if ($contactid == 0) {
1797                 $contactid = twitter_fetch_contact($uid, $post->user, $create_user);
1798
1799                 $postarray['owner-id']     = twitter_get_contact($post->user);
1800                 $postarray['owner-name']   = $post->user->name;
1801                 $postarray['owner-link']   = "https://twitter.com/" . $post->user->screen_name;
1802                 $postarray['owner-avatar'] = twitter_fix_avatar($post->user->profile_image_url_https);
1803         }
1804
1805         if (($contactid == 0) && !$only_existing_contact) {
1806                 $contactid = $self['id'];
1807         } elseif ($contactid <= 0) {
1808                 Logger::info('Contact ID is zero or less than zero.');
1809                 return [];
1810         }
1811
1812         $postarray['contact-id']    = $contactid;
1813         $postarray['verb']          = Activity::POST;
1814         $postarray['author-id']     = $postarray['owner-id'];
1815         $postarray['author-name']   = $postarray['owner-name'];
1816         $postarray['author-link']   = $postarray['owner-link'];
1817         $postarray['author-avatar'] = $postarray['owner-avatar'];
1818         $postarray['plink']         = "https://twitter.com/" . $post->user->screen_name . "/status/" . $post->id_str;
1819         $postarray['app']           = strip_tags($post->source);
1820
1821         if ($post->user->protected) {
1822                 $postarray['private']   = Item::PRIVATE;
1823                 $postarray['allow_cid'] = '<' . $self['id'] . '>';
1824         } else {
1825                 $postarray['private']   = Item::UNLISTED;
1826                 $postarray['allow_cid'] = '';
1827         }
1828
1829         if (!empty($post->full_text)) {
1830                 $postarray['body'] = $post->full_text;
1831         } else {
1832                 $postarray['body'] = $post->text;
1833         }
1834
1835         // When the post contains links then use the correct object type
1836         if (count($post->entities->urls) > 0) {
1837                 $postarray['object-type'] = Activity\ObjectType::BOOKMARK;
1838         }
1839
1840         // Search for media links
1841         twitter_media_entities($post, $postarray, $uriid);
1842
1843         $converted = twitter_expand_entities($postarray['body'], $post);
1844
1845         // When the post contains external links then images or videos are just "decorations".
1846         if (!empty($converted['urls'])) {
1847                 $postarray['post-type'] = Item::PT_NOTE;
1848         }
1849
1850         $postarray['body'] = $converted['body'];
1851         $postarray['created'] = DateTimeFormat::utc($post->created_at);
1852         $postarray['edited'] = DateTimeFormat::utc($post->created_at);
1853
1854         if ($uriid > 0) {
1855                 twitter_store_tags($uriid, $converted['taglist']);
1856                 twitter_store_attachments($uriid, $post);
1857         }
1858
1859         if (!empty($post->place->name)) {
1860                 $postarray["location"] = $post->place->name;
1861         }
1862         if (!empty($post->place->full_name)) {
1863                 $postarray["location"] = $post->place->full_name;
1864         }
1865         if (!empty($post->geo->coordinates)) {
1866                 $postarray["coord"] = $post->geo->coordinates[0] . " " . $post->geo->coordinates[1];
1867         }
1868         if (!empty($post->coordinates->coordinates)) {
1869                 $postarray["coord"] = $post->coordinates->coordinates[1] . " " . $post->coordinates->coordinates[0];
1870         }
1871         if (!empty($post->retweeted_status)) {
1872                 $retweet = twitter_createpost($a, $uid, $post->retweeted_status, $self, false, false, $noquote);
1873
1874                 if (empty($retweet['body'])) {
1875                         return [];
1876                 }
1877
1878                 if (!$noquote) {
1879                         // Store the original tweet
1880                         Item::insert($retweet);
1881
1882                         // CHange the other post into a reshare activity
1883                         $postarray['verb'] = Activity::ANNOUNCE;
1884                         $postarray['gravity'] = GRAVITY_ACTIVITY;
1885                         $postarray['object-type'] = Activity\ObjectType::NOTE;
1886
1887                         $postarray['thr-parent'] = $retweet['uri'];
1888                 } else {
1889                         $retweet['source']       = $postarray['source'];
1890                         $retweet['direction']    = $postarray['direction'];
1891                         $retweet['private']      = $postarray['private'];
1892                         $retweet['allow_cid']    = $postarray['allow_cid'];
1893                         $retweet['contact-id']   = $postarray['contact-id'];
1894                         $retweet['owner-id']     = $postarray['owner-id'];
1895                         $retweet['owner-name']   = $postarray['owner-name'];
1896                         $retweet['owner-link']   = $postarray['owner-link'];
1897                         $retweet['owner-avatar'] = $postarray['owner-avatar'];
1898
1899                         $postarray = $retweet;
1900                 }
1901         }
1902
1903         if (!empty($post->quoted_status)) {
1904                 if ($noquote) {
1905                         // To avoid recursive share blocks we just provide the link to avoid removing quote context.
1906                         $postarray['body'] .= "\n\nhttps://twitter.com/" . $post->quoted_status->user->screen_name . "/status/" . $post->quoted_status->id_str;
1907                 } else {
1908                         $quoted = twitter_createpost($a, 0, $post->quoted_status, $self, false, false, true);
1909                         if (!empty($quoted['body'])) {
1910                                 Item::insert($quoted);
1911                                 $post = Post::selectFirst(['guid', 'uri-id'], ['uri' => $quoted['uri'], 'uid' => 0]);
1912                                 Logger::info('Stored quoted post', ['uid' => $uid, 'uri-id' => $uriid, 'post' => $post]);
1913
1914                                 $postarray['body'] .= "\n" . BBCode::getShareOpeningTag(
1915                                                 $quoted['author-name'],
1916                                                 $quoted['author-link'],
1917                                                 $quoted['author-avatar'],
1918                                                 $quoted['plink'],
1919                                                 $quoted['created'],
1920                                                 $post['guid'] ?? ''
1921                                         );
1922
1923                                 $postarray['body'] .= $quoted['body'] . '[/share]';
1924                         } else {
1925                                 // Quoted post author is blocked/ignored, so we just provide the link to avoid removing quote context.
1926                                 $postarray['body'] .= "\n\nhttps://twitter.com/" . $post->quoted_status->user->screen_name . "/status/" . $post->quoted_status->id_str;
1927                         }
1928                 }
1929         }
1930
1931         return $postarray;
1932 }
1933
1934 /**
1935  * Store tags and mentions
1936  *
1937  * @param integer $uriid
1938  * @param array $taglist
1939  */
1940 function twitter_store_tags(int $uriid, array $taglist)
1941 {
1942         foreach ($taglist as $tag) {
1943                 Tag::storeByHash($uriid, $tag[0], $tag[1], $tag[2]);
1944         }
1945 }
1946
1947 function twitter_fetchparentposts(App $a, $uid, $post, TwitterOAuth $connection, array $self)
1948 {
1949         Logger::info('Fetching parent posts', ['user' => $uid, 'post' => $post->id_str]);
1950
1951         $posts = [];
1952
1953         while (!empty($post->in_reply_to_status_id_str)) {
1954                 try {
1955                         $post = twitter_statuses_show($post->in_reply_to_status_id_str, $connection);
1956                 } catch (TwitterOAuthException $e) {
1957                         Logger::warning('Error fetching parent post', ['uid' => $uid, 'post' => $post->id_str, 'message' => $e->getMessage()]);
1958                         break;
1959                 }
1960
1961                 if (empty($post)) {
1962                         Logger::info("twitter_fetchparentposts: Can't fetch post");
1963                         break;
1964                 }
1965
1966                 if (empty($post->id_str)) {
1967                         Logger::info("twitter_fetchparentposts: This is not a post", ['post' => $post]);
1968                         break;
1969                 }
1970
1971                 if (Post::exists(['uri' => 'twitter::' . $post->id_str, 'uid' => $uid])) {
1972                         break;
1973                 }
1974
1975                 $posts[] = $post;
1976         }
1977
1978         Logger::info("twitter_fetchparentposts: Fetching " . count($posts) . " parents");
1979
1980         $posts = array_reverse($posts);
1981
1982         if (!empty($posts)) {
1983                 foreach ($posts as $post) {
1984                         $postarray = twitter_createpost($a, $uid, $post, $self, false, !DI::pConfig()->get($uid, 'twitter', 'create_user'), false);
1985
1986                         if (empty($postarray['body'])) {
1987                                 continue;
1988                         }
1989
1990                         $item = Item::insert($postarray);
1991
1992                         $postarray["id"] = $item;
1993
1994                         Logger::notice('twitter_fetchparentpost: User ' . $self["nick"] . ' posted parent timeline item ' . $item);
1995                 }
1996         }
1997 }
1998
1999 function twitter_fetchhometimeline(App $a, $uid)
2000 {
2001         $ckey    = DI::config()->get('twitter', 'consumerkey');
2002         $csecret = DI::config()->get('twitter', 'consumersecret');
2003         $otoken  = DI::pConfig()->get($uid, 'twitter', 'oauthtoken');
2004         $osecret = DI::pConfig()->get($uid, 'twitter', 'oauthsecret');
2005         $create_user = DI::pConfig()->get($uid, 'twitter', 'create_user');
2006         $mirror_posts = DI::pConfig()->get($uid, 'twitter', 'mirror_posts');
2007
2008         Logger::info('Fetching timeline', ['uid' => $uid]);
2009
2010         $application_name = DI::config()->get('twitter', 'application_name');
2011
2012         if ($application_name == "") {
2013                 $application_name = DI::baseUrl()->getHostname();
2014         }
2015
2016         $connection = new TwitterOAuth($ckey, $csecret, $otoken, $osecret);
2017
2018         try {
2019                 $own_contact = twitter_fetch_own_contact($a, $uid);
2020         } catch (TwitterOAuthException $e) {
2021                 Logger::warning('Error fetching own contact', ['uid' => $uid, 'message' => $e->getMessage()]);
2022                 return;
2023         }
2024
2025         $contact = Contact::selectFirst(['nick'], ['id' => $own_contact, 'uid' => $uid]);
2026         if (DBA::isResult($contact)) {
2027                 $own_id = $contact['nick'];
2028         } else {
2029                 Logger::warning('Own twitter contact not found', ['uid' => $uid]);
2030                 return;
2031         }
2032
2033         $self = User::getOwnerDataById($uid);
2034         if ($self === false) {
2035                 Logger::warning('Own contact not found', ['uid' => $uid]);
2036                 return;
2037         }
2038
2039         $parameters = ["exclude_replies" => false, "trim_user" => false, "contributor_details" => true, "include_rts" => true, "tweet_mode" => "extended", "include_ext_alt_text" => true];
2040         //$parameters["count"] = 200;
2041         // Fetching timeline
2042         $lastid = DI::pConfig()->get($uid, 'twitter', 'lasthometimelineid');
2043
2044         $first_time = ($lastid == "");
2045
2046         if ($lastid != "") {
2047                 $parameters["since_id"] = $lastid;
2048         }
2049
2050         try {
2051                 $items = $connection->get('statuses/home_timeline', $parameters);
2052         } catch (TwitterOAuthException $e) {
2053                 Logger::warning('Error fetching home timeline', ['uid' => $uid, 'message' => $e->getMessage()]);
2054                 return;
2055         }
2056
2057         if (!is_array($items)) {
2058                 Logger::warning('home timeline is no array', ['items' => $items]);
2059                 return;
2060         }
2061
2062         if (empty($items)) {
2063                 Logger::notice('No new timeline content', ['uid' => $uid]);
2064                 return;
2065         }
2066
2067         $posts = array_reverse($items);
2068
2069         Logger::notice('Processing timeline', ['lastid' => $lastid, 'uid' => $uid, 'count' => count($posts)]);
2070
2071         if (count($posts)) {
2072                 foreach ($posts as $post) {
2073                         if ($post->id_str > $lastid) {
2074                                 $lastid = $post->id_str;
2075                                 DI::pConfig()->set($uid, 'twitter', 'lasthometimelineid', $lastid);
2076                         }
2077
2078                         if ($first_time) {
2079                                 continue;
2080                         }
2081
2082                         if (stristr($post->source, $application_name) && $post->user->screen_name == $own_id) {
2083                                 Logger::info("Skip previously sent post");
2084                                 continue;
2085                         }
2086
2087                         if ($mirror_posts && $post->user->screen_name == $own_id && $post->in_reply_to_status_id_str == "") {
2088                                 Logger::info("Skip post that will be mirrored");
2089                                 continue;
2090                         }
2091
2092                         if ($post->in_reply_to_status_id_str != "") {
2093                                 twitter_fetchparentposts($a, $uid, $post, $connection, $self);
2094                         }
2095
2096                         Logger::info('Preparing post ' . $post->id_str . ' for user ' . $uid);
2097
2098                         $postarray = twitter_createpost($a, $uid, $post, $self, $create_user, true, false);
2099
2100                         if (empty($postarray['body']) || trim($postarray['body']) == "") {
2101                                 Logger::info('Empty body for post ' . $post->id_str . ' and user ' . $uid);
2102                                 continue;
2103                         }
2104
2105                         $notify = false;
2106
2107                         if (empty($postarray['thr-parent'])) {
2108                                 $contact = DBA::selectFirst('contact', [], ['id' => $postarray['contact-id'], 'self' => false]);
2109                                 if (DBA::isResult($contact) && Item::isRemoteSelf($contact, $postarray)) {
2110                                         $notify = PRIORITY_MEDIUM;
2111                                 }
2112                         }
2113
2114                         $item = Item::insert($postarray, $notify);
2115                         $postarray["id"] = $item;
2116
2117                         Logger::notice('User ' . $uid . ' posted home timeline item ' . $item);
2118                 }
2119         }
2120         DI::pConfig()->set($uid, 'twitter', 'lasthometimelineid', $lastid);
2121
2122         Logger::info('Last timeline ID for user ' . $uid . ' is now ' . $lastid);
2123
2124         // Fetching mentions
2125         $lastid = DI::pConfig()->get($uid, 'twitter', 'lastmentionid');
2126
2127         $first_time = ($lastid == "");
2128
2129         if ($lastid != "") {
2130                 $parameters["since_id"] = $lastid;
2131         }
2132
2133         try {
2134                 $items = $connection->get('statuses/mentions_timeline', $parameters);
2135         } catch (TwitterOAuthException $e) {
2136                 Logger::warning('Error fetching mentions', ['uid' => $uid, 'message' => $e->getMessage()]);
2137                 return;
2138         }
2139
2140         if (!is_array($items)) {
2141                 Logger::warning("mentions are no arrays", ['items' => $items]);
2142                 return;
2143         }
2144
2145         $posts = array_reverse($items);
2146
2147         Logger::info("Fetching mentions for user " . $uid . " " . sizeof($posts) . " items");
2148
2149         if (count($posts)) {
2150                 foreach ($posts as $post) {
2151                         if ($post->id_str > $lastid) {
2152                                 $lastid = $post->id_str;
2153                         }
2154
2155                         if ($first_time) {
2156                                 continue;
2157                         }
2158
2159                         if ($post->in_reply_to_status_id_str != "") {
2160                                 twitter_fetchparentposts($a, $uid, $post, $connection, $self);
2161                         }
2162
2163                         $postarray = twitter_createpost($a, $uid, $post, $self, false, !$create_user, false);
2164
2165                         if (empty($postarray['body'])) {
2166                                 continue;
2167                         }
2168
2169                         $item = Item::insert($postarray);
2170
2171                         Logger::notice('User ' . $uid . ' posted mention timeline item ' . $item);
2172                 }
2173         }
2174
2175         DI::pConfig()->set($uid, 'twitter', 'lastmentionid', $lastid);
2176
2177         Logger::info('Last mentions ID for user ' . $uid . ' is now ' . $lastid);
2178 }
2179
2180 function twitter_fetch_own_contact(App $a, $uid)
2181 {
2182         $ckey    = DI::config()->get('twitter', 'consumerkey');
2183         $csecret = DI::config()->get('twitter', 'consumersecret');
2184         $otoken  = DI::pConfig()->get($uid, 'twitter', 'oauthtoken');
2185         $osecret = DI::pConfig()->get($uid, 'twitter', 'oauthsecret');
2186
2187         $own_id = DI::pConfig()->get($uid, 'twitter', 'own_id');
2188
2189         $contact_id = 0;
2190
2191         if ($own_id == "") {
2192                 $connection = new TwitterOAuth($ckey, $csecret, $otoken, $osecret);
2193
2194                 // Fetching user data
2195                 // get() may throw TwitterOAuthException, but we will catch it later
2196                 $user = $connection->get('account/verify_credentials');
2197                 if (empty($user->id_str)) {
2198                         return false;
2199                 }
2200
2201                 DI::pConfig()->set($uid, 'twitter', 'own_id', $user->id_str);
2202
2203                 $contact_id = twitter_fetch_contact($uid, $user, true);
2204         } else {
2205                 $contact = Contact::selectFirst(['id'], ['uid' => $uid, 'alias' => 'twitter::' . $own_id]);
2206                 if (DBA::isResult($contact)) {
2207                         $contact_id = $contact['id'];
2208                 } else {
2209                         DI::pConfig()->delete($uid, 'twitter', 'own_id');
2210                 }
2211         }
2212
2213         return $contact_id;
2214 }
2215
2216 function twitter_is_retweet(App $a, $uid, $body)
2217 {
2218         $body = trim($body);
2219
2220         // Skip if it isn't a pure repeated messages
2221         // Does it start with a share?
2222         if (strpos($body, "[share") > 0) {
2223                 return false;
2224         }
2225
2226         // Does it end with a share?
2227         if (strlen($body) > (strrpos($body, "[/share]") + 8)) {
2228                 return false;
2229         }
2230
2231         $attributes = preg_replace("/\[share(.*?)\]\s?(.*?)\s?\[\/share\]\s?/ism", "$1", $body);
2232         // Skip if there is no shared message in there
2233         if ($body == $attributes) {
2234                 return false;
2235         }
2236
2237         $link = "";
2238         preg_match("/link='(.*?)'/ism", $attributes, $matches);
2239         if (!empty($matches[1])) {
2240                 $link = $matches[1];
2241         }
2242
2243         preg_match('/link="(.*?)"/ism', $attributes, $matches);
2244         if (!empty($matches[1])) {
2245                 $link = $matches[1];
2246         }
2247
2248         $id = preg_replace("=https?://twitter.com/(.*)/status/(.*)=ism", "$2", $link);
2249         if ($id == $link) {
2250                 return false;
2251         }
2252         return twitter_retweet($uid, $id);
2253 }
2254
2255 function twitter_retweet(int $uid, int $id, int $item_id = 0)
2256 {
2257         Logger::info('Retweeting', ['user' => $uid, 'id' => $id]);
2258
2259         $result = twitter_api_post('statuses/retweet', $id, $uid);
2260
2261         Logger::info('Retweeted', ['user' => $uid, 'id' => $id, 'result' => $result]);
2262
2263         if (!empty($item_id) && !empty($result->id_str)) {
2264                 Logger::notice('Update extid', ['id' => $item_id, 'extid' => $result->id_str]);
2265                 Item::update(['extid' => "twitter::" . $result->id_str], ['id' => $item_id]);
2266         }
2267
2268         return !isset($result->errors);
2269 }
2270
2271 function twitter_update_mentions($body)
2272 {
2273         $URLSearchString = "^\[\]";
2274         $return = preg_replace_callback(
2275                 "/@\[url\=([$URLSearchString]*)\](.*?)\[\/url\]/ism",
2276                 function ($matches) {
2277                         if (strpos($matches[1], 'twitter.com')) {
2278                                 $return = '@' . substr($matches[1], strrpos($matches[1], '/') + 1);
2279                         } else {
2280                                 $return = $matches[2] . ' (' . $matches[1] . ')';
2281                         }
2282
2283                         return $return;
2284                 },
2285                 $body
2286         );
2287
2288         return $return;
2289 }
2290
2291 function twitter_convert_share(array $attributes, array $author_contact, $content, $is_quote_share)
2292 {
2293         if (empty($author_contact)) {
2294                 return $content . "\n\n" . $attributes['link'];
2295         }
2296
2297         if (!empty($author_contact['network']) && ($author_contact['network'] == Protocol::TWITTER)) {
2298                 $mention = '@' . $author_contact['nick'];
2299         } else {
2300                 $mention = $author_contact['addr'];
2301         }
2302
2303         return ($is_quote_share ? "\n\n" : '' ) . 'RT ' . $mention . ': ' . $content . "\n\n" . $attributes['link'];
2304 }