Construyendo Con la Twitter API: Creando Amigos para Seguir

Spanish (Español) translation by Rafael Chavarría (you can also view the original English article)

Final product image — What You'll Be Creating

¡Bienvenido! Sé que ha pasado tiempo desde que agregué a nuestra serie Twitter API. He estado algo ocupado. Primero, estuvo el tumor cerebral, después, la radiocirugía robótica, después la Serie Programación Yii en curso y su serie startup relacionada y finalmente, el lanzamiento de Planificador de Reuniones.

Decidí escribir el tutorial de hoy usando la Twitter API para crear amigos (lo que Twitter llama la gente que sigues).

¿Por qué? Bueno, la bizarra elección presidencial de E.U. de 2016 ha resaltado un poco del abuso y acoso que sucede cada día en Twitter, algo sobre lo que la compañía ha hecho poco para filtrar--y como programadores, sabemos que no es tan difícil. Es simplemente temor de perder su audiencia de deplorables llenos de odio quienes manejan una parte significativa del ingreso de publicidad.

Muchas mujeres han dejado el servicio por el acoso continuo--por el cuál Twitter a veces se disculpa, diciendo que está tratando de permitir libre expresión. Francamente, no hay libertad de expresión cuando el acoso abusivo está presente de manera indefinida.

También ha habido algunos artículos resaltando cuántos seguidores de la gente son predominantemente varones. Mientras que Twitter no pregunta a los usuarios su género, analiza estadísticamente el género de cuentas para sus anunciantes.

Y puedes echar un vistazo a los propios estimados demográficos de publicidad de Twitter en sus páginas de analíticas. Como puedes ver abajo, Twitter estima que 69 por ciento de mis seguidores son varones.

Building with Twitter API - Twitter Analytics Gender Estimate

Perdido en el ruido está que las voces de las mujeres pueden ser más difíciles de encontrar en Twitter. Pero están ahí afuera. Pew reporta que 21% de los usuarios femeninos de internet usan Twitter, mientras que el 25% de los usuarios varones de Internet lo hacen.

Building with Twitter API Twitter Demographics via Pew Research

Así que el día de hoy te guiaré a través de usar el Framework Yii2 para PHP para acceder a la API Twitter y automatizar el agregar amigos a las cuentas de Twitter de la gente. (Y si quisieras aprender más sobre Yii2, revisa nuestra serie paralela Programando Con Yii2.)

Y, he creado un sitio web, Twixxr.com, el cuál te permite demostrar la característica agregando mujeres prominentes a en Twitter para seguir en tu cuenta.

Si tienes alguna pregunta o retroalimentación, por favor publícala en los comentarios o contáctame en Twitter @reifman.

Viendo hacia Atrás: Tutoriales API Twitter

Mientras que he escrito un puñado de tutoriales Twitter API en el pasado, todos han estado basados en código Yii 1.x. Yii2 ha estado fuera por un largo tiempo, y mientras he escrito sobre inicio de sesión OAuth, no he escrito sobre aspectos de la API para tu propia cuenta y/o en relación a cuentas autenticadas para el framework actualizado. Y no fue sencillo--no hay complementos Yii2 grandiosos para Twitter todavía.

Aquí están algunos de mis tutoriales pasados para que los revises:

No solo el tutorial de hoy te guiará a través de usar OAuth para autenticar cuentas de visitantes del sitio, sino que también te mostrará cómo agregar amigos a su cuenta usando el acceso que te proporcionan.

Usando la Librería TwitterOAuth PHP

Desafortunadamente, no pude encontrar un complemento robusto funcional Twitter API para Yii2, así que saqué ventaja de la Librería Twitter OAuth PHP para crear mi propio modelo Twitter.

Muchas APIs complejas no proporcionan buena documentación, y aprecié la guía en vivo paso a paso que TwitterOAuth proporciona. Es increíblemente útil:

Building with the Twitter API Step from TwitterOAuth Walkthrough

Metas de Producto de Servicio

El servicio Twixxr autenticará a los visitantes del sitio y después automáticamente agregará nuevos amigos a sus cuentas. Los amigos serán elegidos de más de 600 mujeres influyentes que identifiqué en Twitter:

Building Twitter API Twixxr Service Home Page

Comencemos recorriendo el código.

Autenticando un Usuario

Mi TwitterController.php tiene dos métodos básicos, Request y Return. Aquí está el método Request:

public function actionRequest()
  {
    if (Yii::$app->user->isGuest) {
      // user has not logged in to yii site
      $t = new Twitter();
      $url = $t->getAuthorizeUrl();
      $this->redirect($url);
    } else {
      // already verified with us, look up their access keys
      $t = new Twitter();
      $t->refreshConnection(Yii::$app->user->getId());
      $this->goHome();
    }
  }

El modelo Twitter.php invocado en new Twitter(); obtiene un getAuthorizeURL() para que redirijas a un visitante del sitio a la página de autenticación de Twitter, ej. https://api.twitter.com/oauth/authorize?oauth_token=q-7ChxxxxxxxxnpXAAABzzzzzzz6E:

Building with Twitter API OAuth Authorize Redirect

Una vez que el usuario autoriza tu aplicación en Twitter, ellos son redirigidos de vuelta a nuestro método Return:

public function actionReturn()
    {
      // returning from authentication
        /* If the oauth_token is old redirect to the connect page. */
        if (isset($_REQUEST['oauth_token']) && Yii::$app->session['oauth_token'] !== $_REQUEST['oauth_token']) {
            Yii::$app->session['oauth_status'] = 'oldtoken';
            return $this->goHome();
        }
        $t = new Twitter();
        $user_id = $t->getConnection($_REQUEST['oauth_verifier']);
        $person = new \common\models\User;
        $identity = $person->findIdentity($user_id);
        $u = User::findOne($user_id);
        if ($identity->validateAuthKey($u->auth_key)) {
            Yii::$app->user->login($identity);
        }
        $this->redirect(['twixxr/amplify']);        
    }

El modelo Twitter usa la llave de consumidor y secreto de consumidor de tu aplicación, que recibes cuando la registras con el servicio:

<?php

namespace frontend\models;

use Yii;
use yii\base\Model;
use common\models\User;
use frontend\models\Auth;
use Abraham\TwitterOAuth\TwitterOAuth;
/**
 * This is the model class for table "payment".
 *
 * @property integer $id
 * @property integer $user_id
 * @property string $amount
 * @property integer $created_at
 * @property integer $updated_at
 *
 * @property User $user
 */

class Twitter extends Model {
   public $consumerKey;
   public $consumerSecret;
   public $connection;

  public function init() {
    $this->consumerKey = Yii::$app->components['authClientCollection']['clients']['twitter']['consumerKey'];
    $this->consumerSecret = Yii::$app->components['authClientCollection']['clients']['twitter']['consumerSecret'];
  }

El método Return mostrado arriba entonces registra un usuario y almacena tus llaves de acceso de largo plazo para la cuenta---esto permite que hagas llamadas API a su nombre indefinidamente:

public function getConnection($oauth_verifier='') {
    $connection = new TwitterOAuth($this->consumerKey, $this->consumerSecret,Yii::$app->session['oauth_token'],Yii::$app->session['oauth_token_secret']);
    /* Create TwitteroAuth object with app key/secret and token key/secret from default phase */
    $access_token = $connection->oauth("oauth/access_token", ["oauth_verifier" => $oauth_verifier]);
    /* Save the access tokens. Normally these would be saved in a database for future use. */
    $user_id=$this->register($access_token);
    //Yii::$app->session['access_token'] = $access_token;
    /* Remove no longer needed request tokens */
    unset(Yii::$app->session['oauth_token']);
    unset(Yii::$app->session['oauth_token_secret']);
    $this->connection = new TwitterOAuth($this->consumerKey, $this->consumerSecret, $access_token['oauth_token'], $access_token['oauth_token_secret']);
    return $user_id;
  }

  public function register($access_token) {
      $screen_name = $access_token['screen_name'];
      $source_id = $access_token['user_id'];
      $user = User::find()->where(['username'=>$screen_name])->one();
      if (is_null($user)) {
        // sign them up
        $user = new User();
        $user->username = $screen_name;
        $user->email = $screen_name.'@twixxr.com';
        $user->setPassword(Yii::$app->security->generateRandomString(12));
        $user->generateAuthKey();
        $user->save();
      }
      $auth = Auth::find()->where(['source_id'=>$source_id])->one();
      if (is_null($auth)) {
        // add an auth entry
        $auth = new Auth();
        $auth->user_id = $user->id;
        $auth->source = 'twitter';
        $auth->source_id = $source_id;
        $auth->screen_name = $user->username;
        $auth->oauth_token = $access_token['oauth_token'];
        $auth->oauth_token_secret = $access_token['oauth_token_secret'];
        $auth->x_auth_expires =0;
        $auth->save();
      } else {
        $auth->oauth_token = $access_token['oauth_token'];
        $auth->oauth_token_secret = $access_token['oauth_token_secret'];
        $auth->update();
      }
      return $user->id;
    }

Para acceso lectura escritura a sus cuentas, estoy extendiendo la tabla Auth desde el simple acceso de autenticación descrito en nuestra serie Startup Simplificando Onramp Con OAuth para incluir estas llaves extra de verificación.

También te aliento a recorrer la guía paso a paso en TwitterOAuth. Es una excelente ejemplo mostrando todo en acción con tu propia cuenta Twitter.

Importando Nombres, Bios de Perfil, y Fotos

Después, creé un modelo Twixxr.php que podría proporcionar una variedad de funciones importantes específicas al servicio. Primero, creé Twixxr::loadProfiles() para sincronizar nombres, bios y conteos relacionados con Twitter, ej. fotos de perfil, publicaciones de estado, seguidores, siguiendo, de cada mujer identificada en mi base de datos estática de elementos.

public function loadProfiles() {
      // clean Item table
      $this->cleanup();
      $t = new Twitter();
      $t->refreshConnection(1); // for admin user = 1
      $time_stale = time()-(24*3600);
      $people = Item::find()
        ->where('updated_at<'.$time_stale)
        ->orWhere('updated_at=created_at')
        ->orderBy('rand()')->all();
      $cnt=0;
      foreach ($people as $i) {
        // to do - or if updated at is stale
        if ($i->detail=='') {
            $result = $t->getUsersShow($i->path);
            echo $i->path.', ';
            if (isset($result->errors)) {
              var_dump($result);
              continue;
            }
            if (isset($result->name)) {
              $i->title = Html::encode($this->removeEmoji($result->name));
              if ($i->title=='') {
                $i->title='n/a';
              }
            }
            if (isset($result->screen_name)) {
                $i->path = $result->screen_name;
            }
            if (isset($result->description)) {
              $i->detail=Html::encode($this->removeEmoji($result->description));
            }
            if (isset($result->profile_image_url_https)) {
              $i->image_url = $result->profile_image_url_https;
            }
            $i->validate();
            var_dump($i->getErrors());
            $i->update();
           SocialProfile::fill($i->id,$result);
           $cnt+=1;
           if ($cnt>25) exit;
        }
      }
  }

Esto es llamado por un cron job de consola el cuál describiré después en la serie Yii2. Así que estos perfiles están sincronizados gradualmente y repetidamente en intervalos específicos a lo largo de varios días.

Seguir: Crea una Amistad

No lo detallaré aquí, pero básicamente creé una tabla Log de peticiones individuales para cada usuario y cuenta femenina. En otras palabras, Samuel tendría 500 entradas pidiendo una adición de amistad para cada mujer en la base de datos.

Primero, sin embargo,me aseguraría de que Samuel (y todo usuario de Twixxr) siguiera la cuenta Twixxr_com.

$result = $t->createFriend('twixxr_com');
          $total_request+=1;
          if ($result !== false) {
            $action->status = Log::STATUS_COMPLETE;
            $action->save();
          }

Antes de que el cron job procese estos comados, este refresca la autorización Twitter y conexión para Samuel y cada usuario individual en la etapa apropiada:

$t->refreshConnection($action->user_id);

Entonces, aquí está el método Twitter::createFriend($screen_name):

public function createFriend($username) {
    $add = $this->connection
        ->post("friendships/create", ["screen_name" => $username]);
    if ($this->connection->getLastHttpCode() == 200) {
      // successful
      return $add;
    } else {
        // Handle error case
        return false;
    }
  }

Después, hace esto para todas las mujeres solicitadas por Samuel como se detalla en la tabla Log---y por su puesto, hay mucho sucediendo abajo, lo que describiré:

echo 'add '.$person->path.' to '.$action->user_id.'<br />';
          if ($x>7) {
            $mode ='limited';
            echo 'Limited to max requests per user<br />';
            // skip this user and go to next one...
            continue; // on to next user
          }
          $followed_by = $t->getFriendshipsShow($u->username,$person->path);
          if ($followed_by == -10) {
            echo 'rate limit error<br />';
            $mode ='limited';
            // skip this user and go to next one...
            continue; // on to next user
          } else if ($followed_by==0) {
            $x+=1;
            echo 'request follow<br />';
            $result = $t->createFriend($person->path);
            $total_request+=1;
            if ($result !== false) {
              $action->status = Log::STATUS_COMPLETE;
              $action->completion_at = time();
              $action->save();
            } else {
              echo 'skip due to error';
              $action->status = Log::STATUS_SKIP_ERROR;
              $action->completion_at = time();
              $action->save();
            }
          } else {
            echo 'already followed<br /><br />';
            $action->status = Log::STATUS_SKIPPED;
            $action->save();
          }
        }

La API de Twitter tiene un límite estricto de tarifa, y hace usar su API un poco difícil a veces. El cron job de arriba crea amistades para siete columnas meta a la vez cambiando a la petición de otro usuario hasta que sea llamada de nuevo.

Aquí está Twitter::getFriendshipsShow(), que revisa para ver si esta cuenta ya está siguiendo a la cuenta deseada. En el código de arriba, salta peticiones que son redundantes, para ahorrar el límite de tarifa.

public function getFriendshipsShow($source_name,$target_name) {
    $result = $this->connection->get("friendships/show", ["source_screen_name" => $source_name,"target_screen_name" => $target_name]);
    if (isset($result->errors)) {
      if ($result->errors[0]->message=='Rate limit exceeded') {
        return -10;
      }
    } else {
      if (isset($result->relationship->target->followed_by)) {
        if  ($result->relationship->target->followed_by) {
          return 1;
        } else {
          return 0;
        }
      }
    }
    return -1;
  }

En el futuro cercano, implementaré la abultada API de Twitter para esto, haciendo solo una llamada en vez de cientos por usuario usando get/friendships/lookup. Nota que necesitarás una cuenta de desarrollador para acceder a esta página.

Dejar de seguir: Destruye una Amistad

También puedes deshacer estas amistades vía la API:

$statuses = $connection->post("friendships/destroy", ["screen_name" => $u]);

Estoy registrando cada conexión que hace Twixxr, y si los límites de tarifa de Twitter fueran menos onerosos y consumidores de tiempo, permitiría a los visitantes tener una característica de deshacer para Twixxr, para dejar de seguir a todas las mujeres si no les gustan las nuevas cuentas.

Rendimiento

Hice mucho en Twixxr para administrar rendimiento. Básicamente, construí la tabla Log para registrar rápidamente las peticiones de amistad del usuario. Pero todas estas son procesadas en el fondo.

Desafortunadamente, la API de twitter no permite publicar una lista de cuentas para seguir en masa. Simplemente no hay forma de hacer esto en tiempo real mientras el usuario está en tu sitio.

Así que la respuesta del usuario a peticiones Twixxr es inmediata, pero podría tomar varias horas o más para que todas las cuentas sean seguidas.

Aquí está el método sigue a Todos TwixxterController.php:

public function actionAll()
    {
      // make request for authenticated user to follow all twitter profiles
      $x = new Twixxr();
      $x->followTwixxr(Yii::$app->user->getId());
      $x->followAll(Yii::$app->user->getId());
      Yii::$app->getSession()->setFlash('success', Yii::t('frontend','Your request has been added to our queue.'));
      $this->redirect(['twixxr/complete',['task'=>'all']]);
      // redir home
    }

Aquí están los métodos Twixxr::followAll y followCount que también son usados por los botones numerados de arriba, para seguir a 100, 200, 300 mujeres, etc.

public function followAll($user_id) {
    $allWomen = Item::find()->count();
    $this->followCount($user_id,$allWomen);
  }

  public function followCount($user_id,$cnt=100) {
    $women = Item::find()->orderBy('rand()')->limit($cnt)->all();
    foreach ($women as $w) {
        $l = Log::find()
          ->where(['user_id'=>$user_id,'item_id'=>$w->id])
          ->one();
        if (!is_null($l)) {
          $l->status = Log::STATUS_PENDING;
          $l->update();
        }  else {
          $l = new Log();
          $l->user_id = $user_id;
          $l->item_id = $w->id;
          $l->event_id = Twixxr::EVENT_ADD;
          $l->status = Log::STATUS_PENDING;
          $l->save();
        }
    }
  }

Solo están creando entradas de Registro para cada petición de amistad para que el cron job procese el fondo.

¿Qué Sigue?

Espero que hayas disfrutado aprender sobre usar TwitterOAuth.php en Yii2 y cómo autorizar y aplicar la Twitter API en relación a los usuarios de tu sitio.

Después, me gustaría usar la Twitter API para analizar a mis propios seguidores. Tengo la sospecha de que la gran mayoría de seguidores son robots de spam, y me gustaría usar la API para probar esto. Mantente en sintonía.

Si tienes alguna pregunta o sugerencia, por favor publicalas en los comentarios. Si quisieras mantenerte al día en mis siguientes tutoriales Envato Tuts+ y otras series, por favor visita mi página de instructor o sigue @reifman. Definitivamente revisa mi serie statup y Planificador de Reuniones.