Google+
4elements web design & consultancy

Shineyrock

web design & consultancy
Shineyrock web design & consultancy

Shineyrock

  1. web design and consultancy

blog

  1. Home
  2. blog
  3. read
  4. Building With the Twitter API: Managing Lists
  • like 1 31

    Building With the Twitter API: Managing Lists

    1. August 2015
    2. Daily
    3. read 839

    Final product image
    What You'll Be Creating

    This is part two of our Twitter List API tutorial within our broader Twitter API series. In this tutorial, we'll walk through building List features with the API. Code samples are provided in the Github repository. Installation instructions are described in more detail here (be sure to use the repository provided in this tutorial and not the initial Birdcage repository listed on that page).

    Overview of the Twitter List API

    Again, there are roughly 19 APIs for Twitter Lists, divided into three major areas:

    Let's begin with integrating some of the basic features of List API development.

    Creating a List

    When you load Birdcage, you'll see the Manage Lists page. Click the Create a List option in the right sidebar menu.

    Twitter List API Manage Lists empty

    The Create a List form will be displayed. I'm going to create a list for tracking Seattle journalists on Twitter:

    Twitter List API Create a List

    Here's the Create code in TwitterlistController.php. It handles code for displaying the form and, after the form is posted, code for processing:

        public function actionCreate()
	{
		$model=new TwitterList;
		$this->performAjaxValidation($model);
		if(!isset($_POST['TwitterList'])) {
		  // initial load
		  // load the current selected account as a default
  		$model->account_id = Yii::app()->session['account_id'];
  		// display form
  		$this->render('create',array(
  			'model'=>$model,
  		));		  
		} else {
		  // POSTed - process form
			$model->attributes=$_POST['TwitterList'];
			// load the account selected
		  $account = Account::model()->findByPK($model->account_id);
		  // connect to twitter
		  $twitter = Yii::app()->twitter->getTwitterTokened($account['oauth_token'], $account['oauth_token_secret']);
			// create remotely at Twitter
      $new_list= $twitter->post("lists/create",array('name'=>$model->name,'description'=>$model->description,'mode'=>$model->getModeString($model->mode))); 
			if (TwitterList::model()->isError($new_list)) {
			  // to do - set flash error
  			var_dump($new_list);
  			yexit();
			} else {
  			$model->owner_id =$account->twitter_id;
  			$model->list_id =$new_list->id_str;
  			$model->slug=$new_list->slug;
  			$model->full_name=$new_list->full_name;
        $model->created_at = date( 'Y-m-d H:i:s', strtotime($new_list->created_at) );
        $model->modified_at =new CDbExpression('NOW()');          			
  			if($model->save())
  				$this->redirect(array('admin'));			  
			}
		}
	}

    You can read documentation for the Twitter Lists/Create API here.

    Once the form is submitted, you'll see something like this:

    Twitter List API Manage Twittert Lists after Create

    Importing Members to a List

    One of the most frustrating limitations of the Twitter List user interface is how difficult it is to add members. You have to visit each member and add them individually to your lists—the process is very convoluted and slow.

    We're going to implement a feature to subscribe a comma-separated list of Twitter accounts.

    In the list view, if you click on the Manage List icon to the right of Seattle Journalists, you'll see the View List page:

    Twitter List API View List Members empty

    Click on Import members in the right sidebar menu. Then, type in the list of Twitter accounts you wish to add to this list:

    Twitter List API Import Twitter Accounts to List

    Let's review the code that uploads the members to Twitter. The code for displaying the form above begins in ListMemberController.php:

        /**
	 * Import members to a list
	 */
	public function actionImport($id)
	{
	      $model = new Import();
    		$model->list_id = $id;
    		// Uncomment the following line if AJAX validation is needed
    		$this->performAjaxValidation($model);
    		if(isset($_POST['Import']))
    		{
    			if($model->save()) {
    			  $result = ListMember::model()->import($id,$_POST['Import']['member_list']);
            Yii::app()->user->setFlash('import_success','Thank you! Your members have been added.');
        		$this->redirect(array('/twitterlist/view','id'=>$id));
            } // end if save
    			 // end if post
  			} else {
      		$this->render('import',array(
      			'model'=>$model,'list_id'=>$id,
      		));  			  
  			}	
  	}

    In the ListMember.php model, the import code looks as follows. We use preg_split to convert the list of accounts to an array. Then, for each account, we fetch information about the account at Users/Show and post the Twitter ID to Lists Member Create.

    public function import($id,$import_list) { 
      // retrieve account
	  $tl = TwitterList::model()->findByAttributes(array('id'=>$id));
	  $list_id = $tl['list_id'];
	  $account = Account::model()->findByPk($tl->account_id);
    // retrieve members and add to list
    $twitter = Yii::app()->twitter->getTwitterTokened($account['oauth_token'], $account['oauth_token_secret']);
    // convert post rows to array
    $add_list = preg_split ("(\r|\n|,)", $import_list, -1, PREG_SPLIT_NO_EMPTY);
    $max_count = 0;
    foreach ($add_list as $item) {
        $item = trim($item);
        $user_info= $twitter->get("users/show",array('screen_name'=>$item)); 
        if (ErrorLog::model()->isError('getUserInfo', $account['id'], $user_info)) {
          continue;
        }            
        if (ErrorLog::model()->isRateLimited($user_info)) {
          continue;
        }
          // add remotely to list
        $people= $twitter->post("lists/members/create",array('list_id'=>$list_id,'screen_name'=>$item)); 
        // add locally to db
        $this->remote_add($list_id,$user_info->id_str,$item);
        $max_count+=1;
        if ($max_count>=99) break; 
    }
	}

  	public function remote_add($list_id,$member_id,$screen_name = 'tbd') {
      TwitterUser::model()->setPlaceholder($member_id,$screen_name); 
      $lm = ListMember::model()->findByAttributes(array('list_id'=>$list_id,'member_id'=>$member_id));
      if (empty($lm)) {
    	  $lm = new ListMember;
    	  $lm->list_id=$list_id;
    	  $lm->member_id=$member_id;
    	  $lm->save();
    	}
  	}

    After submitting the members, you'll see something like this:

    Twitter List API View List Members

    The tbd represents a user that isn't already in our database; the profile information will be fetched (hydrated) in the background later.

    On Twitter, you'll see something like this:

    Twitter List API List Member View at Twitter

    Synchronizing Lists

    Now that we've created a list, let's fetch the lists that already exist in our account so that we can manage them from our console. Again, from the Manage Lists menu, click Synchronize Lists.

    Twitter List API Manage Lists

    The sync action is coded in TwitterlistController.php:

        public function actionSync()
	{
	  TwitterList::model()->sync();
		$this->redirect(array('admin'));
	}

    The TwitterList.php model sync operation is relatively sophisticated, as shown below. First, the sync model loops through all of the accounts you've configured and calls the syncOne account for lists.

    SyncOne calls fetch Lists/Ownerships in the API to find all the lists owned by each account. 

        public function sync() {
	  $users = User::model()->findAll();
    foreach ($users as $user) {
      $user_id = $user['id'];
      $accounts = Account::model()->findAllByAttributes(array('user_id'=>$user_id));      
      // loop through Twitter accounts (may be multiple)
      foreach ($accounts as $account) {
        $this->syncOne($account['id']);
      } // end account loop
    } // end user loop  
	}
	
	public function syncOne($account_id) {
	  $account=Account::model()->findByPk($account_id);
    $twitter = Yii::app()->twitter->getTwitterTokened($account['oauth_token'], $account['oauth_token_secret']);
    // fetch lists owned by this account
    $twitter_lists= $twitter->get("lists/ownerships",array('count'=>100,'cursor'=>-1)); 
    //print_r($twitter_lists);
    if (count($twitter_lists->lists)==0) return;
    foreach ($twitter_lists->lists as $tl) {
      //echo $tl->id_str.' '.$tl->slug.' '.$tl->member_count;lb();
      $this->remote_add($account_id,$tl);
      // spawn action to get list members
      $this->addMembershipAction($account_id,$tl->id_str);
    }	 // end loop of lists  
	}

    However, rather than try to fetch the members for the list in real time, which would likely time out, it creates a background action to fetch the members for a given list.

        public function addMembershipAction($account_id,$item_id) {
	  // adds a background task action to retrieve memberships for a list id
     $check_dup = Action::model()->findByAttributes(array('account_id'=>$account_id,'action'=>Action::ACTION_MEMBERSHIPS,'status'=>Action::STATUS_ACTIVE,'item_id'=>$item_id));
     if (empty($check_dup)) {
        $a = new Action();
        $a->account_id = $account_id;
        $a->action = Action::ACTION_MEMBERSHIPS;
        $a->item_id = $item_id;
        $a->last_tweet_id = 0; // set cursor
        $a->status = Action::STATUS_ACTIVE;
        $a->created_at =new CDbExpression('NOW()');          
        $a->modified_at =new CDbExpression('NOW()');          
     	  $a->save();   
     	}
	}

    The background cron task invokes the Action.php model which calls getListMembership for one list at a time.

        public function getListMembership($action,$limit = 50) {
      // collect next $limit members of list
      $account = Account::model()->findByPk($action->account_id);
      // last_tweet_id is the cursor 
      $cursor = $action->last_tweet_id;
      if ($cursor ==0 ) $cursor =-1; // since last_tweet_id is unsigned, can't store -1 start	    
      $result = TwitterList::model()->getMemberships($account, $action->item_id, $cursor , $limit);
      $a = Action::model()->findByPk($action->id);
      if ($result->rateLimit) {
        return false;
      } else if ($result->complete) {
        $a->status=self::STATUS_COMPLETE;
        $a->save();
      } else {
          // set lowest cursor
          $a->last_tweet_id = $result->cursor;
          $a->save();
      } 
	}

    When the task runs, it invokes the TwitterList.php model's getMemberships method. This method uses cursoring to page through member records without timing out or hitting rate limits. The last cursor is stored in the Action table so that the next background invocation can continue adding members where it left off previously. 

        public function getMemberships($account,$list_id, $cursor =-1,$limit = 200) {
	    echo 'entering getMemberships: account_id:'.$account['id'].' list_id:'.$list_id.' cursor: '.$cursor;lb();
      $result = new StdClass;
      $result->cursor = -1;
      $result->count =0;
      $result->error =false;
      $result->complete = false;
      $result->rateLimit = false;
      $count_people = 0;
      // retrieve members and add to list
      $twitter = Yii::app()->twitter->getTwitterTokened($account['oauth_token'], $account['oauth_token_secret']);
      echo 'here'.$cursor;lb();
      while ($cursor <>0 ) {
        echo 'inside';lb();
        $people= $twitter->get("lists/members",array('list_id'=>$list_id,'cursor'=>$cursor,'skip_status'=>true,'include_entities'=>false)); 
        if (ErrorLog::model()->isError('getMemberships', $account['id'], $people)) {
          $result->error =false;
          return $result;
        }              
        if (ErrorLog::model()->isRateLimited($people)) {
         $result->rateLimit = true;
         return $result;
        }
        if (isset($people->next_cursor))
          $cursor = $people->next_cursor;
        else
          $cursor = 0;
        $result->cursor = $cursor;
        $count_people+=count($people->users);
        echo 'Count people: '.count($people->users);lb();
        foreach ($people->users as $u) {
          //var_dump($u);lb();
          echo 'Member:'.$u->screen_name;lb();
          if (isset($u->screen_name))
            $screen_name = $u->screen_name;
          else
            $screen_name = 'tbd';
          ListMember::model()->remote_add($list_id,$u->id_str,$screen_name);
        }        
        if (count($people->users)==0 or $cursor==0) {
          $result->complete = true;      
          return $result;
        }
      } // end while loop
      echo 'exiting getMemberships';lb();	    
      return $result;        
	}

    You should see something like this when the operation completes:

    Twitter List API Manage Lists

    Once the background tasks complete, you'll see members for each list like this:

    Twitter List API View List Members

    What's Next?

    I hope you've enjoyed this Twitter List API series thus far. I'd like to hear your suggestions of favorite API scenarios and feature requests; please post them in the comments.

    If you have any questions or suggestions, please post them in the comments. If you'd like to keep up on my future Tuts+ tutorials and other series, please visit my instructor page or follow @reifman.

    Related Links

    Photo

    martijn broeders

    founder/ strategic creative at shineyrock web design & consultancy
    e-mail: .(JavaScript must be enabled to view this email address)
    phone: 434 210 0245
    1
    Add a comment...
    4elements
    Comments

By - category

By - date

Copyright © 1999 - 2026 Shineyrock web design and consultancy, All Rights Reserved / Terms of Conditions / Sitemap: XML, HTML, Images, Mobile, News