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['contact']['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                 Contact::removeFollower($hook_data['contact']);
 187                 Contact::unfollow($hook_data['contact']['id'], $hook_data['uid']);
 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-name'] = $postarray['owner-name'];
1895                         $retweet['owner-link'] = $postarray['owner-link'];
1896                         $retweet['owner-avatar'] = $postarray['owner-avatar'];
1897
1898                         $postarray = $retweet;
1899                 }
1900         }
1901
1902         if (!empty($post->quoted_status)) {
1903                 if ($noquote) {
1904                         // To avoid recursive share blocks we just provide the link to avoid removing quote context.
1905                         $postarray['body'] .= "\n\nhttps://twitter.com/" . $post->quoted_status->user->screen_name . "/status/" . $post->quoted_status->id_str;
1906                 } else {
1907                         $quoted = twitter_createpost($a, 0, $post->quoted_status, $self, false, false, true);
1908                         if (!empty($quoted['body'])) {
1909                                 Item::insert($quoted);
1910                                 $post = Post::selectFirst(['guid', 'uri-id'], ['uri' => $quoted['uri'], 'uid' => 0]);
1911                                 Logger::info('Stored quoted post', ['uid' => $uid, 'uri-id' => $uriid, 'post' => $post]);
1912
1913                                 $postarray['body'] .= "\n" . BBCode::getShareOpeningTag(
1914                                                 $quoted['author-name'],
1915                                                 $quoted['author-link'],
1916                                                 $quoted['author-avatar'],
1917                                                 $quoted['plink'],
1918                                                 $quoted['created'],
1919                                                 $post['guid'] ?? ''
1920                                         );
1921
1922                                 $postarray['body'] .= $quoted['body'] . '[/share]';
1923                         } else {
1924                                 // Quoted post author is blocked/ignored, so we just provide the link to avoid removing quote context.
1925                                 $postarray['body'] .= "\n\nhttps://twitter.com/" . $post->quoted_status->user->screen_name . "/status/" . $post->quoted_status->id_str;
1926                         }
1927                 }
1928         }
1929
1930         return $postarray;
1931 }
1932
1933 /**
1934  * Store tags and mentions
1935  *
1936  * @param integer $uriid
1937  * @param array $taglist
1938  */
1939 function twitter_store_tags(int $uriid, array $taglist)
1940 {
1941         foreach ($taglist as $tag) {
1942                 Tag::storeByHash($uriid, $tag[0], $tag[1], $tag[2]);
1943         }
1944 }
1945
1946 function twitter_fetchparentposts(App $a, $uid, $post, TwitterOAuth $connection, array $self)
1947 {
1948         Logger::info('Fetching parent posts', ['user' => $uid, 'post' => $post->id_str]);
1949
1950         $posts = [];
1951
1952         while (!empty($post->in_reply_to_status_id_str)) {
1953                 try {
1954                         $post = twitter_statuses_show($post->in_reply_to_status_id_str, $connection);
1955                 } catch (TwitterOAuthException $e) {
1956                         Logger::warning('Error fetching parent post', ['uid' => $uid, 'post' => $post->id_str, 'message' => $e->getMessage()]);
1957                         break;
1958                 }
1959
1960                 if (empty($post)) {
1961                         Logger::info("twitter_fetchparentposts: Can't fetch post");
1962                         break;
1963                 }
1964
1965                 if (empty($post->id_str)) {
1966                         Logger::info("twitter_fetchparentposts: This is not a post", ['post' => $post]);
1967                         break;
1968                 }
1969
1970                 if (Post::exists(['uri' => 'twitter::' . $post->id_str, 'uid' => $uid])) {
1971                         break;
1972                 }
1973
1974                 $posts[] = $post;
1975         }
1976
1977         Logger::info("twitter_fetchparentposts: Fetching " . count($posts) . " parents");
1978
1979         $posts = array_reverse($posts);
1980
1981         if (!empty($posts)) {
1982                 foreach ($posts as $post) {
1983                         $postarray = twitter_createpost($a, $uid, $post, $self, false, !DI::pConfig()->get($uid, 'twitter', 'create_user'), false);
1984
1985                         if (empty($postarray['body'])) {
1986                                 continue;
1987                         }
1988
1989                         $item = Item::insert($postarray);
1990
1991                         $postarray["id"] = $item;
1992
1993                         Logger::notice('twitter_fetchparentpost: User ' . $self["nick"] . ' posted parent timeline item ' . $item);
1994                 }
1995         }
1996 }
1997
1998 function twitter_fetchhometimeline(App $a, $uid)
1999 {
2000         $ckey    = DI::config()->get('twitter', 'consumerkey');
2001         $csecret = DI::config()->get('twitter', 'consumersecret');
2002         $otoken  = DI::pConfig()->get($uid, 'twitter', 'oauthtoken');
2003         $osecret = DI::pConfig()->get($uid, 'twitter', 'oauthsecret');
2004         $create_user = DI::pConfig()->get($uid, 'twitter', 'create_user');
2005         $mirror_posts = DI::pConfig()->get($uid, 'twitter', 'mirror_posts');
2006
2007         Logger::info('Fetching timeline', ['uid' => $uid]);
2008
2009         $application_name = DI::config()->get('twitter', 'application_name');
2010
2011         if ($application_name == "") {
2012                 $application_name = DI::baseUrl()->getHostname();
2013         }
2014
2015         $connection = new TwitterOAuth($ckey, $csecret, $otoken, $osecret);
2016
2017         try {
2018                 $own_contact = twitter_fetch_own_contact($a, $uid);
2019         } catch (TwitterOAuthException $e) {
2020                 Logger::warning('Error fetching own contact', ['uid' => $uid, 'message' => $e->getMessage()]);
2021                 return;
2022         }
2023
2024         $contact = Contact::selectFirst(['nick'], ['id' => $own_contact, 'uid' => $uid]);
2025         if (DBA::isResult($contact)) {
2026                 $own_id = $contact['nick'];
2027         } else {
2028                 Logger::warning('Own twitter contact not found', ['uid' => $uid]);
2029                 return;
2030         }
2031
2032         $self = User::getOwnerDataById($uid);
2033         if ($self === false) {
2034                 Logger::warning('Own contact not found', ['uid' => $uid]);
2035                 return;
2036         }
2037
2038         $parameters = ["exclude_replies" => false, "trim_user" => false, "contributor_details" => true, "include_rts" => true, "tweet_mode" => "extended", "include_ext_alt_text" => true];
2039         //$parameters["count"] = 200;
2040         // Fetching timeline
2041         $lastid = DI::pConfig()->get($uid, 'twitter', 'lasthometimelineid');
2042
2043         $first_time = ($lastid == "");
2044
2045         if ($lastid != "") {
2046                 $parameters["since_id"] = $lastid;
2047         }
2048
2049         try {
2050                 $items = $connection->get('statuses/home_timeline', $parameters);
2051         } catch (TwitterOAuthException $e) {
2052                 Logger::warning('Error fetching home timeline', ['uid' => $uid, 'message' => $e->getMessage()]);
2053                 return;
2054         }
2055
2056         if (!is_array($items)) {
2057                 Logger::warning('home timeline is no array', ['items' => $items]);
2058                 return;
2059         }
2060
2061         if (empty($items)) {
2062                 Logger::notice('No new timeline content', ['uid' => $uid]);
2063                 return;
2064         }
2065
2066         $posts = array_reverse($items);
2067
2068         Logger::notice('Processing timeline', ['lastid' => $lastid, 'uid' => $uid, 'count' => count($posts)]);
2069
2070         if (count($posts)) {
2071                 foreach ($posts as $post) {
2072                         if ($post->id_str > $lastid) {
2073                                 $lastid = $post->id_str;
2074                                 DI::pConfig()->set($uid, 'twitter', 'lasthometimelineid', $lastid);
2075                         }
2076
2077                         if ($first_time) {
2078                                 continue;
2079                         }
2080
2081                         if (stristr($post->source, $application_name) && $post->user->screen_name == $own_id) {
2082                                 Logger::info("Skip previously sent post");
2083                                 continue;
2084                         }
2085
2086                         if ($mirror_posts && $post->user->screen_name == $own_id && $post->in_reply_to_status_id_str == "") {
2087                                 Logger::info("Skip post that will be mirrored");
2088                                 continue;
2089                         }
2090
2091                         if ($post->in_reply_to_status_id_str != "") {
2092                                 twitter_fetchparentposts($a, $uid, $post, $connection, $self);
2093                         }
2094
2095                         Logger::info('Preparing post ' . $post->id_str . ' for user ' . $uid);
2096
2097                         $postarray = twitter_createpost($a, $uid, $post, $self, $create_user, true, false);
2098
2099                         if (empty($postarray['body']) || trim($postarray['body']) == "") {
2100                                 Logger::info('Empty body for post ' . $post->id_str . ' and user ' . $uid);
2101                                 continue;
2102                         }
2103
2104                         $notify = false;
2105
2106                         if (empty($postarray['thr-parent'])) {
2107                                 $contact = DBA::selectFirst('contact', [], ['id' => $postarray['contact-id'], 'self' => false]);
2108                                 if (DBA::isResult($contact) && Item::isRemoteSelf($contact, $postarray)) {
2109                                         $notify = PRIORITY_MEDIUM;
2110                                 }
2111                         }
2112
2113                         $item = Item::insert($postarray, $notify);
2114                         $postarray["id"] = $item;
2115
2116                         Logger::notice('User ' . $uid . ' posted home timeline item ' . $item);
2117                 }
2118         }
2119         DI::pConfig()->set($uid, 'twitter', 'lasthometimelineid', $lastid);
2120
2121         Logger::info('Last timeline ID for user ' . $uid . ' is now ' . $lastid);
2122
2123         // Fetching mentions
2124         $lastid = DI::pConfig()->get($uid, 'twitter', 'lastmentionid');
2125
2126         $first_time = ($lastid == "");
2127
2128         if ($lastid != "") {
2129                 $parameters["since_id"] = $lastid;
2130         }
2131
2132         try {
2133                 $items = $connection->get('statuses/mentions_timeline', $parameters);
2134         } catch (TwitterOAuthException $e) {
2135                 Logger::warning('Error fetching mentions', ['uid' => $uid, 'message' => $e->getMessage()]);
2136                 return;
2137         }
2138
2139         if (!is_array($items)) {
2140                 Logger::warning("mentions are no arrays", ['items' => $items]);
2141                 return;
2142         }
2143
2144         $posts = array_reverse($items);
2145
2146         Logger::info("Fetching mentions for user " . $uid . " " . sizeof($posts) . " items");
2147
2148         if (count($posts)) {
2149                 foreach ($posts as $post) {
2150                         if ($post->id_str > $lastid) {
2151                                 $lastid = $post->id_str;
2152                         }
2153
2154                         if ($first_time) {
2155                                 continue;
2156                         }
2157
2158                         if ($post->in_reply_to_status_id_str != "") {
2159                                 twitter_fetchparentposts($a, $uid, $post, $connection, $self);
2160                         }
2161
2162                         $postarray = twitter_createpost($a, $uid, $post, $self, false, !$create_user, false);
2163
2164                         if (empty($postarray['body'])) {
2165                                 continue;
2166                         }
2167
2168                         $item = Item::insert($postarray);
2169
2170                         Logger::notice('User ' . $uid . ' posted mention timeline item ' . $item);
2171                 }
2172         }
2173
2174         DI::pConfig()->set($uid, 'twitter', 'lastmentionid', $lastid);
2175
2176         Logger::info('Last mentions ID for user ' . $uid . ' is now ' . $lastid);
2177 }
2178
2179 function twitter_fetch_own_contact(App $a, $uid)
2180 {
2181         $ckey    = DI::config()->get('twitter', 'consumerkey');
2182         $csecret = DI::config()->get('twitter', 'consumersecret');
2183         $otoken  = DI::pConfig()->get($uid, 'twitter', 'oauthtoken');
2184         $osecret = DI::pConfig()->get($uid, 'twitter', 'oauthsecret');
2185
2186         $own_id = DI::pConfig()->get($uid, 'twitter', 'own_id');
2187
2188         $contact_id = 0;
2189
2190         if ($own_id == "") {
2191                 $connection = new TwitterOAuth($ckey, $csecret, $otoken, $osecret);
2192
2193                 // Fetching user data
2194                 // get() may throw TwitterOAuthException, but we will catch it later
2195                 $user = $connection->get('account/verify_credentials');
2196                 if (empty($user->id_str)) {
2197                         return false;
2198                 }
2199
2200                 DI::pConfig()->set($uid, 'twitter', 'own_id', $user->id_str);
2201
2202                 $contact_id = twitter_fetch_contact($uid, $user, true);
2203         } else {
2204                 $contact = Contact::selectFirst(['id'], ['uid' => $uid, 'alias' => 'twitter::' . $own_id]);
2205                 if (DBA::isResult($contact)) {
2206                         $contact_id = $contact['id'];
2207                 } else {
2208                         DI::pConfig()->delete($uid, 'twitter', 'own_id');
2209                 }
2210         }
2211
2212         return $contact_id;
2213 }
2214
2215 function twitter_is_retweet(App $a, $uid, $body)
2216 {
2217         $body = trim($body);
2218
2219         // Skip if it isn't a pure repeated messages
2220         // Does it start with a share?
2221         if (strpos($body, "[share") > 0) {
2222                 return false;
2223         }
2224
2225         // Does it end with a share?
2226         if (strlen($body) > (strrpos($body, "[/share]") + 8)) {
2227                 return false;
2228         }
2229
2230         $attributes = preg_replace("/\[share(.*?)\]\s?(.*?)\s?\[\/share\]\s?/ism", "$1", $body);
2231         // Skip if there is no shared message in there
2232         if ($body == $attributes) {
2233                 return false;
2234         }
2235
2236         $link = "";
2237         preg_match("/link='(.*?)'/ism", $attributes, $matches);
2238         if (!empty($matches[1])) {
2239                 $link = $matches[1];
2240         }
2241
2242         preg_match('/link="(.*?)"/ism', $attributes, $matches);
2243         if (!empty($matches[1])) {
2244                 $link = $matches[1];
2245         }
2246
2247         $id = preg_replace("=https?://twitter.com/(.*)/status/(.*)=ism", "$2", $link);
2248         if ($id == $link) {
2249                 return false;
2250         }
2251         return twitter_retweet($uid, $id);
2252 }
2253
2254 function twitter_retweet(int $uid, int $id, int $item_id = 0)
2255 {
2256         Logger::info('Retweeting', ['user' => $uid, 'id' => $id]);
2257
2258         $result = twitter_api_post('statuses/retweet', $id, $uid);
2259
2260         Logger::info('Retweeted', ['user' => $uid, 'id' => $id, 'result' => $result]);
2261
2262         if (!empty($item_id) && !empty($result->id_str)) {
2263                 Logger::notice('Update extid', ['id' => $item_id, 'extid' => $result->id_str]);
2264                 Item::update(['extid' => "twitter::" . $result->id_str], ['id' => $item_id]);
2265         }
2266
2267         return !isset($result->errors);
2268 }
2269
2270 function twitter_update_mentions($body)
2271 {
2272         $URLSearchString = "^\[\]";
2273         $return = preg_replace_callback(
2274                 "/@\[url\=([$URLSearchString]*)\](.*?)\[\/url\]/ism",
2275                 function ($matches) {
2276                         if (strpos($matches[1], 'twitter.com')) {
2277                                 $return = '@' . substr($matches[1], strrpos($matches[1], '/') + 1);
2278                         } else {
2279                                 $return = $matches[2] . ' (' . $matches[1] . ')';
2280                         }
2281
2282                         return $return;
2283                 },
2284                 $body
2285         );
2286
2287         return $return;
2288 }
2289
2290 function twitter_convert_share(array $attributes, array $author_contact, $content, $is_quote_share)
2291 {
2292         if (empty($author_contact)) {
2293                 return $content . "\n\n" . $attributes['link'];
2294         }
2295
2296         if (!empty($author_contact['network']) && ($author_contact['network'] == Protocol::TWITTER)) {
2297                 $mention = '@' . $author_contact['nick'];
2298         } else {
2299                 $mention = $author_contact['addr'];
2300         }
2301
2302         return ($is_quote_share ? "\n\n" : '' ) . 'RT ' . $mention . ': ' . $content . "\n\n" . $attributes['link'];
2303 }