plugins/TwitterBridge/TwitterBridgePlugin.php

   1 <?php
   2 /**
   3  * StatusNet, the distributed open-source microblogging tool
   4  *
   5  * PHP version 5
   6  *
   7  * LICENCE: This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  *
  20  * @category  Plugin
  21  * @package   StatusNet
  22  * @author    Zach Copley <zach@status.net>
  23  * @author    Julien C <chaumond@gmail.com>
  24  * @copyright 2009-2010 Control Yourself, Inc.
  25  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html GNU Affero General Public License version 3.0
  26  * @link      http://status.net/
  27  */
  28
  29 if (!defined('STATUSNET')) {
  30     exit(1);
  31 }
  32
  33 require_once INSTALLDIR . '/plugins/TwitterBridge/twitter.php';
  34
  35 /**
  36  * Plugin for sending and importing Twitter statuses
  37  *
  38  * This class allows users to link their Twitter accounts
  39  *
  40  * @category Plugin
  41  * @package  StatusNet
  42  * @author   Zach Copley <zach@status.net>
  43  * @author   Julien C <chaumond@gmail.com>
  44  * @license  http://www.fsf.org/licensing/licenses/agpl-3.0.html GNU Affero General Public License version 3.0
  45  * @link     http://status.net/
  46  * @link     http://twitter.com/
  47  */
  48 class TwitterBridgePlugin extends Plugin
  49 {
  50     const VERSION = STATUSNET_VERSION;
  51     public $adminImportControl = false; // Should the 'import' checkbox be exposed in the admin panel?
  52
  53     /**
  54      * Initializer for the plugin.
  55      */
  56     function initialize()
  57     {
  58         // Allow the key and secret to be passed in
  59         // Control panel will override
  60
  61         if (isset($this->consumer_key)) {
  62             $key = common_config('twitter', 'consumer_key');
  63             if (empty($key)) {
  64                 Config::save('twitter', 'consumer_key', $this->consumer_key);
  65             }
  66         }
  67
  68         if (isset($this->consumer_secret)) {
  69             $secret = common_config('twitter', 'consumer_secret');
  70             if (empty($secret)) {
  71                 Config::save(
  72                     'twitter',
  73                     'consumer_secret',
  74                     $this->consumer_secret
  75                 );
  76             }
  77         }
  78     }
  79
  80     /**
  81      * Check to see if there is a consumer key and secret defined
  82      * for Twitter integration.
  83      *
  84      * @return boolean result
  85      */
  86     static function hasKeys()
  87     {
  88         $ckey    = common_config('twitter', 'consumer_key');
  89         $csecret = common_config('twitter', 'consumer_secret');
  90
  91         if (empty($ckey) && empty($csecret)) {
  92             $ckey    = common_config('twitter', 'global_consumer_key');
  93             $csecret = common_config('twitter', 'global_consumer_secret');
  94         }
  95
  96         if (!empty($ckey) && !empty($csecret)) {
  97             return true;
  98         }
  99
 100         return false;
 101     }
 102
 103     /**
 104      * Add Twitter-related paths to the router table
 105      *
 106      * Hook for RouterInitialized event.
 107      *
 108      * @param Net_URL_Mapper $m path-to-action mapper
 109      *
 110      * @return boolean hook return
 111      */
 112     function onRouterInitialized($m)
 113     {
 114         $m->connect('admin/twitter', array('action' => 'twitteradminpanel'));
 115
 116         if (self::hasKeys()) {
 117             $m->connect(
 118                 'twitter/authorization',
 119                 array('action' => 'twitterauthorization')
 120             );
 121             $m->connect(
 122                 'settings/twitter', array(
 123                     'action' => 'twittersettings'
 124                     )
 125                 );
 126             if (common_config('twitter', 'signin')) {
 127                 $m->connect(
 128                     'main/twitterlogin',
 129                     array('action' => 'twitterlogin')
 130                 );
 131             }
 132         }
 133
 134         return true;
 135     }
 136
 137     /*
 138      * Add a login tab for 'Sign in with Twitter'
 139      *
 140      * @param Action &action the current action
 141      *
 142      * @return void
 143      */
 144     function onEndLoginGroupNav(&$action)
 145     {
 146         $action_name = $action->trimmed('action');
 147
 148         if (self::hasKeys() && common_config('twitter', 'signin')) {
 149             $action->menuItem(
 150                 common_local_url('twitterlogin'),
 151                 _m('Twitter'),
 152                 _m('Login or register using Twitter'),
 153                 'twitterlogin' === $action_name
 154             );
 155         }
 156
 157         return true;
 158     }
 159
 160     /**
 161      * Add the Twitter Settings page to the Connect Settings menu
 162      *
 163      * @param Action &$action The calling page
 164      *
 165      * @return boolean hook return
 166      */
 167     function onEndConnectSettingsNav(&$action)
 168     {
 169         if (self::hasKeys()) {
 170             $action_name = $action->trimmed('action');
 171
 172             $action->menuItem(
 173                 common_local_url('twittersettings'),
 174                 _m('Twitter'),
 175                 _m('Twitter integration options'),
 176                 $action_name === 'twittersettings'
 177             );
 178         }
 179         return true;
 180     }
 181
 182     /**
 183      * Automatically load the actions and libraries used by the Twitter bridge
 184      *
 185      * @param Class $cls the class
 186      *
 187      * @return boolean hook return
 188      *
 189      */
 190     function onAutoload($cls)
 191     {
 192         $dir = dirname(__FILE__);
 193
 194         switch ($cls) {
 195         case 'TwittersettingsAction':
 196         case 'TwitterauthorizationAction':
 197         case 'TwitterloginAction':
 198         case 'TwitteradminpanelAction':
 199             include_once $dir . '/' . strtolower(mb_substr($cls, 0, -6)) . '.php';
 200             return false;
 201         case 'TwitterOAuthClient':
 202         case 'TwitterQueueHandler':
 203             include_once $dir . '/' . strtolower($cls) . '.php';
 204             return false;
 205         case 'Notice_to_status':
 206         case 'Twitter_synch_status':
 207             include_once $dir . '/' . $cls . '.php';
 208             return false;
 209         default:
 210             return true;
 211         }
 212     }
 213
 214     /**
 215      * Add a Twitter queue item for each notice
 216      *
 217      * @param Notice $notice      the notice
 218      * @param array  &$transports the list of transports (queues)
 219      *
 220      * @return boolean hook return
 221      */
 222     function onStartEnqueueNotice($notice, &$transports)
 223     {
 224         if (self::hasKeys() && $notice->isLocal()) {
 225             // Avoid a possible loop
 226             if ($notice->source != 'twitter') {
 227                 array_push($transports, 'twitter');
 228             }
 229         }
 230         return true;
 231     }
 232
 233     /**
 234      * Add Twitter bridge daemons to the list of daemons to start
 235      *
 236      * @param array $daemons the list fo daemons to run
 237      *
 238      * @return boolean hook return
 239      */
 240     function onGetValidDaemons($daemons)
 241     {
 242         if (self::hasKeys()) {
 243             array_push(
 244                 $daemons,
 245                 INSTALLDIR
 246                 . '/plugins/TwitterBridge/daemons/synctwitterfriends.php'
 247             );
 248             if (common_config('twitterimport', 'enabled')) {
 249                 array_push(
 250                     $daemons,
 251                     INSTALLDIR
 252                     . '/plugins/TwitterBridge/daemons/twitterstatusfetcher.php'
 253                     );
 254             }
 255         }
 256
 257         return true;
 258     }
 259
 260     /**
 261      * Register Twitter notice queue handler
 262      *
 263      * @param QueueManager $manager
 264      *
 265      * @return boolean hook return
 266      */
 267     function onEndInitializeQueueManager($manager)
 268     {
 269         if (self::hasKeys()) {
 270             $manager->connect('twitter', 'TwitterQueueHandler');
 271         }
 272         return true;
 273     }
 274
 275     /**
 276      * Add a Twitter tab to the admin panel
 277      *
 278      * @param Widget $nav Admin panel nav
 279      *
 280      * @return boolean hook value
 281      */
 282
 283     function onEndAdminPanelNav($nav)
 284     {
 285         if (AdminPanelAction::canAdmin('twitter')) {
 286
 287             $action_name = $nav->action->trimmed('action');
 288
 289             $nav->out->menuItem(
 290                 common_local_url('twitteradminpanel'),
 291                 _m('Twitter'),
 292                 _m('Twitter bridge configuration'),
 293                 $action_name == 'twitteradminpanel',
 294                 'nav_twitter_admin_panel'
 295             );
 296         }
 297
 298         return true;
 299     }
 300
 301     /**
 302      * Plugin version data
 303      *
 304      * @param array &$versions array of version blocks
 305      *
 306      * @return boolean hook value
 307      */
 308     function onPluginVersion(&$versions)
 309     {
 310         $versions[] = array(
 311             'name' => 'TwitterBridge',
 312             'version' => self::VERSION,
 313             'author' => 'Zach Copley, Julien C',
 314             'homepage' => 'http://status.net/wiki/Plugin:TwitterBridge',
 315             'rawdescription' => _m(
 316                 'The Twitter "bridge" plugin allows integration ' .
 317                 'of a StatusNet instance with ' .
 318                 '<a href="http://twitter.com/">Twitter</a>.'
 319             )
 320         );
 321         return true;
 322     }
 323
 324     /**
 325      * Expose the adminImportControl setting to the administration panel code.
 326      * This allows us to disable the import bridge enabling checkbox for administrators,
 327      * since on a bulk farm site we can't yet automate the import daemon setup.
 328      *
 329      * @return boolean hook value;
 330      */
 331     function onTwitterBridgeAdminImportControl()
 332     {
 333         return (bool)$this->adminImportControl;
 334     }
 335
 336     /**
 337      * When the site is set to ssl=sometimes mode, we should make sure our
 338      * various auth-related pages are on SSL to keep things looking happy.
 339      * Although we're not submitting passwords directly, we do link out to
 340      * an authentication source and it's a lot happier if we've got some
 341      * protection against MitM.
 342      *
 343      * @param string $action name
 344      * @param boolean $ssl outval to force SSL
 345      * @return mixed hook return value
 346      */
 347     function onSensitiveAction($action, &$ssl)
 348     {
 349         $sensitive = array('twitteradminpanel',
 350                            'twittersettings',
 351                            'twitterauthorization',
 352                            'twitterlogin');
 353         if (in_array($action, $sensitive)) {
 354             $ssl = true;
 355             return false;
 356         } else {
 357             return true;
 358         }
 359     }
 360
 361     /**
 362      * Database schema setup
 363      *
 364      * We maintain a table mapping StatusNet notices to Twitter statuses
 365      *
 366      * @see Schema
 367      * @see ColumnDef
 368      *
 369      * @return boolean hook value; true means continue processing, false means stop.
 370      */
 371     function onCheckSchema()
 372     {
 373         $schema = Schema::get();
 374
 375         // For saving the last-synched status of various timelines
 376         // home_timeline, messages (in), messages (out), ...
 377
 378         $schema->ensureTable('twitter_synch_status',
 379                              array(new ColumnDef('foreign_id', 'bigint', null,
 380                                                  false, 'PRI'),
 381                                    new ColumnDef('timeline', 'varchar', 255,
 382                                                  false, 'PRI'),
 383                                    new ColumnDef('last_id', 'bigint', null, // XXX: check for PostgreSQL
 384                                                  false),
 385                                    new ColumnDef('created', 'datetime', null,
 386                                                  false),
 387                                    new ColumnDef('modified', 'datetime', null,
 388                                                  false)));
 389
 390         // For storing user-submitted flags on profiles
 391
 392         $schema->ensureTable('notice_to_status',
 393                              array(new ColumnDef('notice_id', 'integer', null,
 394                                                  false, 'PRI'),
 395                                    new ColumnDef('status_id', 'bigint', null, // XXX: check for PostgreSQL
 396                                                  false, 'UNI'),
 397                                    new ColumnDef('created', 'datetime', null,
 398                                                  false)));
 399
 400         return true;
 401     }
 402
 403     /**
 404      * If a notice gets deleted, remove the Notice_to_status mapping and
 405      * delete the status on Twitter.
 406      *
 407      * @param User   $user   The user doing the deleting
 408      * @param Notice $notice The notice getting deleted
 409      *
 410      * @return boolean hook value
 411      */
 412     function onStartDeleteOwnNotice(User $user, Notice $notice)
 413     {
 414         $n2s = Notice_to_status::staticGet('notice_id', $notice->id);
 415
 416         if (!empty($n2s)) {
 417
 418             $flink = Foreign_link::getByUserID($notice->profile_id,
 419                                                TWITTER_SERVICE); // twitter service
 420
 421             if (empty($flink)) {
 422                 return true;
 423             }
 424
 425             if (!TwitterOAuthClient::isPackedToken($flink->credentials)) {
 426                 $this->log(LOG_INFO, "Skipping deleting notice for {$notice->id} since link is not OAuth.");
 427                 return true;
 428             }
 429
 430             $token = TwitterOAuthClient::unpackToken($flink->credentials);
 431             $client = new TwitterOAuthClient($token->key, $token->secret);
 432
 433             $client->statusesDestroy($n2s->status_id);
 434
 435             $n2s->delete();
 436         }
 437         return true;
 438     }
 439
 440     /**
 441      * Notify remote users when their notices get favorited.
 442      *
 443      * @param Profile or User $profile of local user doing the faving
 444      * @param Notice $notice being favored
 445      * @return hook return value
 446      */
 447     function onEndFavorNotice(Profile $profile, Notice $notice)
 448     {
 449         $flink = Foreign_link::getByUserID($profile->id,
 450                                            TWITTER_SERVICE); // twitter service
 451
 452         if (empty($flink)) {
 453             return true;
 454         }
 455
 456         if (!TwitterOAuthClient::isPackedToken($flink->credentials)) {
 457             $this->log(LOG_INFO, "Skipping fave processing for {$profile->id} since link is not OAuth.");
 458             return true;
 459         }
 460
 461         $status_id = twitter_status_id($notice);
 462
 463         if (empty($status_id)) {
 464             return true;
 465         }
 466
 467         $token = TwitterOAuthClient::unpackToken($flink->credentials);
 468         $client = new TwitterOAuthClient($token->key, $token->secret);
 469
 470         $client->favoritesCreate($status_id);
 471
 472         return true;
 473     }
 474
 475     /**
 476      * Notify remote users when their notices get de-favorited.
 477      *
 478      * @param Profile $profile Profile person doing the de-faving
 479      * @param Notice  $notice  Notice being favored
 480      *
 481      * @return hook return value
 482      */
 483     function onEndDisfavorNotice(Profile $profile, Notice $notice)
 484     {
 485         $flink = Foreign_link::getByUserID($profile->id,
 486                                            TWITTER_SERVICE); // twitter service
 487
 488         if (empty($flink)) {
 489             return true;
 490         }
 491
 492         if (!TwitterOAuthClient::isPackedToken($flink->credentials)) {
 493             $this->log(LOG_INFO, "Skipping fave processing for {$profile->id} since link is not OAuth.");
 494             return true;
 495         }
 496
 497         $status_id = twitter_status_id($notice);
 498
 499         if (empty($status_id)) {
 500             return true;
 501         }
 502
 503         $token = TwitterOAuthClient::unpackToken($flink->credentials);
 504         $client = new TwitterOAuthClient($token->key, $token->secret);
 505
 506         $client->favoritesDestroy($status_id);
 507
 508         return true;
 509     }
 510 }