Joey Rivera » twitter

Twitter API, OAuth Authentication, and Zend_Oauth Tutorial

Joey — Mon, 25 Oct 2010 20:52:03 +0000

I recently had to work on a project that required me to interact with the Twitter API. I had done this before so I wasn’t expecting anything different until I remembered that Twitter had changed their API to start using OAuth for authentication. If you are not familiar with OAuth, it’s a secure way of authenticating without requiring a user to submit their username and password to third-parties – you can read more about it at OAuth. There are lots of resources online that talk about this in detail but I wasn’t able to find one that explained the entire process in a way that made sense. Hopefully this post will give you everything you need to get started with the Twitter API. I’m going to go through the steps required to make this work without using the entire zend framework.

Objective

This tutorial will go step-by-step in explaining how to create a small PHP application that can interact with the Twitter API. Our goal is to:

Authenticate
Display our latest tweets
Post new tweets from PHP
Display the last few times our account was mentioned

The only assumptions at this point (other than knowing PHP) is that you have a twitter account and the zend framework library downloaded. We won’t be using the entire framework, just some of the files as standalone modules.

Registering An App

The first step in being able to communicate with the Twitter API is to register an app in their system so you can receive all the necessary keys to authenticate with OAuth. Go to dev.twitter.com and log in with your Twitter account. Now click on ‘register an app’ (if that link is not visible then click on ‘your apps’ on the top right and then click on ‘register an app’ in the next page). These are the values I put in the form on the next page for my app. Feel free to follow along. I’ll explain the important inputs.

Application: Joey’s Blog Example
Description: Twitter PHP App
Application Website: http://www.joeyrivera.com
Organization: None
Application Type: Browser
Callback URL: http://www.joeyrivera.com/twitter/callback.php
Default Access Type: Read & Write

Most of the above are self-explanatory but let me explain callback since it’s an important one. Before we can talk to Twitter, we need to authenticate to get a token from Twitter. Once we have our token, we can start calling the API. During authentication, we are actually going to leave our application and go to Twitters website where the user will have to enter their twitter credentials. After the user allows our application and is done authenticating, Twitter will redirect the user back to our applications callback url. We haven’t created the file yet, but point back to a file called ‘callback.php’ where you plan on putting this file. We will create this file later. (I mentioned users don’t have to give third-parties their user/pass but they still have to let Twitter know it’s ok for this app to access their account.)

Enter the captcha and register. At this point we have successfully registered our app that can now start communicating with the Twitter API.

Authenticating

To authenticate using Zend_Oauth we need to create a consumer object. The consumer needs an array with the following parameters:

callbackUrl: Same as the one used during ‘registering an app’.
siteUrl: The url where the token request will take place. In this case: ‘http://twitter.com/oauth’.
consumerKey: This value is assigned to you after registering your app. To get this value, log into dev.twitter.com, go to your apps, and select the app you just created during ‘registering an app’ above. All your keys/secret and info will be listed on that page.
consumerSecret: same steps as consumerKey.

We are going to be using the code from zend docs with a couple minor tweaks or additions. The code is below:

authenticate.php

session_start();

set_include_path(‘/path/to/zend/library/1.10.8′);
require ‘Zend/Oauth/Consumer.php’;

$config = array(
‘callbackUrl’ => ‘http://www.joeyrivera.com/twitter/callback.php’,
‘siteUrl’ => ‘http://twitter.com/oauth’,
‘consumerKey’ => ‘ASD234ADF34ADSF’,
‘consumerSecret’ => ’24GH789JSDFGDFG345098DF09873SDFSD’
);

$consumer = new Zend_Oauth_Consumer($config);

// fetch a request token
$token = $consumer->getRequestToken();

// persist the token to storage
$_SESSION[‘TWITTER_REQUEST_TOKEN’] = serialize($token);

// redirect the user
$consumer->redirect();

Create a file and paste the above code in there and save your file as authenticate.php. Go back and modify the values of the $config array to use your callbackUrl, siteUrl, consumerKey, and consumerSecret. Also make sure to modify the include path to include your library folder where the zend framework resides (I’m using the framework version 1.10.8 for these examples).

Quick explanation of the code. First we start our session since we’ll be using a session variable to track the request token needed to create the access token later. Then we create a consumer and create the request token. Finally we call redirect on the consumer which sends us to twitter feeding it all the necessary information in the proper format for us to then authenticate. There is lots of magic going on behind the scene and for a better understanding on how the token and signature works read the OAuth docs. I personally find it much easier to use Zend_Oauth instead.

Now lets create the callback file, code is below:

callback.php

session_start();

set_include_path(‘/path/to/zend/library/1.10.8′);
require ‘Zend/Oauth/Consumer.php’;

$consumer = new Zend_Oauth_Consumer($config);

if (!empty($_GET) && isset($_SESSION[‘TWITTER_REQUEST_TOKEN’]))
{
$token = $consumer->getAccessToken($_GET, unserialize($_SESSION[‘TWITTER_REQUEST_TOKEN’]));

// Now that we have an Access Token, we can discard the Request Token
$_SESSION[‘TWITTER_REQUEST_TOKEN’] = null;
} else {
// Mistaken request? Some malfeasant trying something?
exit(‘Invalid callback request. Oops. Sorry.’);
}

// save token to file
file_put_contents(‘token.txt’, serialize($token));

Save this file as callback.php after modifying the $config variables and library path just like with authenticate.php. We are once again starting our session to be able to capture the ‘TWITTER_REQUEST_TOKEN’ created in the previous step. Then we create the consumer again and check to make sure the session is there and that we received query string parameters from Twitter. If everything is as expected, we feed the consumer all the information and ask it for an access token. This is the token we need to track since it’s the token we need for any call our application makes to the Twitter API. Since we no longer need the request token, we can remove it from the session.

The last step is to save the token somewhere so we can reuse it and not have to authenticate again. Twitter’s access token does not expire (at least not now). This means, once we authenticate with Twitter, as long as we have our access token stored and accessible to us, our client will not have to authenticate again (assuming Twitter doesn’t change their mind later and adds an expiration to their tokens). For the purpose of this example, I’m storing this token in the file system. Another option is to store this value in the database, it’s really up to you where you want to put it. If you are saving it to the file system, make sure that file is writable by your application.

Both files are created so lets try it out. Go to your browser and access the authenticate.php file. When the page loads, you should be redirected to Twitter and asked to log in (unless you are already logged into Twitter). Enter your twitter account user/pass that you want to access and continue. Next you’ll be asked if you want to allow this application to access your account. Go ahead and click allow, then you’ll be taken to your callback.php url. At this point we have authorized, received our access token, and stored it. Now we are done with our first goal and ready for the good stuff.

Using our Token

Our next goal was to display our latest tweets so this will be our first example on how to use our token. Technically, this isn’t the best example as you don’t need to authenticate with Twitter to display public user tweets but you’ll still get to see how to make a call to the Twitter API using our token.

show_tweets.php

set_include_path(‘/path/to/zend/library/1.10.8′);
require ‘Zend/Oauth/Consumer.php’;

$token = unserialize(file_get_contents(‘token.txt’));

$client = $token->getHttpClient($config);
$client->setUri(‘http://twitter.com/statuses/user_timeline.json’);
$client->setMethod(Zend_Http_Client::GET);
$client->setParameterGet(‘screen_name’, ‘joeyrivera’);
$client->setParameterGet(‘count’, ’10′);
$response = $client->request();

$tweets = json_decode($response->getBody());

foreach($tweets as $tweet)
{
echo $tweet->text, "
";
}

Paste the above code into a file called show_tweets.php and edit the configs yet again plus the library. At this point I’ll stop mentioning to edit the config and library – just remember to do the same with the next couple examples. First we get our token which we saved to a file during the callback phase. Then we create a client object, tell it what url to call, the method to use and pass two params to let the API know who’s tweets we want and how many tweets to return. Finally we tell the client to initiate the request and we display it when it comes back.

Where did I get the uri from? from Twitters docs page. Spend some time there learning all the different methods you can call and what the required parameters are. For user_timeline (which is what we want to get our latest tweets) we need to call the uri used above. The last part, the .json at the end tells Twitter that we want a JSON encoded response back which is why we need to do a json_decode on the body to view it. You could have used .xml if you wanted an xml back instead. The docs for user_timeline also specify you need to do a get which is why we set it as a method and add the two get parameters. There are more parameters you can set if you like.

This is what I see when I run this page with my screen name:

Flash, jQuery, and Php - what a pain you have all been to me today but I'm glad all is well again.
Put my car up on autotrader, check it out if you are in the market for a 2005 Subaru WRX STi or know someone who might: http://is.gd/g3tqv
someone owns a image rollover patent? http://arstechnica.com/tech-policy/news/2010/10/patent-troll-takes-over-the-web-can-it-be-stopped.ars
Microsoft has the best commercials! http://holykaw.alltop.com/microsoft-pokes-fun-at-smartphone-users-in-ne
Finally got oAuth working to post to Twitter from PHP.
Accidentally found this very cool video by RefinedData http://refineddata.com/products/refinedtraining/index.php
You guys have recommendations on course authoring tools like articulate/captivate that don't have a player. Just a place to create content?
Cool story on YouTube instant http://www.feross.org/youtube-instant-media-frenzy/ Congrats to Feross on the accomplishment.
After driving a Z06 Corvette, I have become a believer of American muscle. STi was fun but just doesn't compare to a Z06.
Been week since we paid for Adobe developer support license and we are still not closer to solving our problem. Hoping to make progress soon

Now lets submit a tweet.

submit_tweet.php

set_include_path(‘/path/to/zend/library/1.10.8′);
require ‘Zend/Oauth/Consumer.php’;

$token = unserialize(file_get_contents(‘token.txt’));

$client = $token->getHttpClient($config);
$client->setUri(‘http://twitter.com/statuses/update.json’);
$client->setMethod(Zend_Http_Client::POST);
$client->setParameterPost(‘status’, ‘I hope to get my blog post on Twitter API with Zend_Oauth up in the next day.’);
$response = $client->request();

$data = json_decode($response->getBody());
echo $data->text;

The code is very similar. The resource we want to call this time is statuses/update. It requires a post method so we use POST and setParameterPost instead of GET. The one required param is status – set that to the string you want to tweet and run this page. Now go check your tweeter account and you should have that status show up. Make sure the string you pass is 140 characters or less. Also, twitter won’t allow you to submit two identical statuses so if you are testing this code and it’s not working, make sure you are sending a unique string.

Finally we’ll create one last example that displays the last 5 mentions of our twitter account.

mentioned_tweet.php

set_include_path(‘/path/to/zend/library/1.10.8′);
require ‘Zend/Oauth/Consumer.php’;

$token = unserialize(file_get_contents(‘token.txt’));

$client = $token->getHttpClient($config);
$client->setUri(‘http://twitter.com/statuses/mentions.json’);
$client->setMethod(Zend_Http_Client::GET);
$client->setParameterGet(‘count’, ’5′);
$response = $client->request();

$tweets = json_decode($response->getBody());

foreach($tweets as $tweet)
{
echo $tweet->text, "
";
}

The mentions resource uses GET and doesn’t require any parameter. I’m passing a count of 5 so you don’t get too much back. Here is what I see when I run this page:

heads up! @mosesngone and @joeyrivera consuming Web Services Nov 4th @atlantaphp #atlantaphp http://meetu.ps/3Rbt

Conclusion

Using Zend_Oauth it’s really easy to authenticate with OAuth and track your token. At that point calling the Twitter API is very simple. I want to thank the guys at Zend for making our lives so much easier with all these great modules. If you have any question feel free to ask. Hopefully you have all found this post very informative and helpful.

EDIT: Here is a similar post on using Facebooks Graph API with their PHP SDK

Using Zend_Paginator with Twitter API and Zend_Cache

Joey — Thu, 28 Jan 2010 19:15:08 +0000

Zend Framework 1.10.0 is out and a comment was posted on my blog that lead me to creating this new post. I’m going to focus more on Zend_Paginator and Zend_Rest_Client to access Twitters API since I’ve already created a post on Zend_Cache. Normally, I would use Zend_Service_Twitter to access the twitter service but it still seems to require authentication to retrieve a users timeline where only protected users should require authentication.

Zend_Paginator

Zend_Paginator from the Zend Framework site:

Zend_Paginator is a flexible component for paginating collections of data and presenting that data to users.

Zend_Paginator automatically creates pagination for you by setting up a few parameters and passing it an array of data. What is pagination, if you have ever gone to Google and searched for anything, usually you’ll see something like the following at the bottom of the search results page:

See the numbers and the text links, this is called pagination. So much data exists for the particular search that it wouldn’t make sense to display it all in one page. It would cause large amounts of scrolling down to view, the load time of the page would be affected, so we rather show fewer results and give our users the option of viewing more by clicking on the pagination links.

To demonstrate how to use Zend_Paginator I created a sample Zend Framework 1.10.0 application. This application grabs my last 50 tweets using the Twitter API and displays them 10 at a time using Zend_Paginator. I use Zend_Cache to cache my twitter data so I don’t have to spend time accessing their api every time – I’m sure they would appreciate it.

Bootstrap

The first step was to create a new zend framework project. I’m making the assumption that if you are reading this then you already know how to do this. After creating my new project, I added two methods to my bootstrap file to autoload and to init Zend_Cache. My bootstrap looks like the following:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
protected function _initAutoload()
{
$autoloader = new Zend_Application_Module_Autoloader(array(
‘namespace’ => ‘My’,
‘basePath’ => APPLICATION_PATH,
));
}

protected function _initCache()
{
$front = array(
‘lifetime’ => 10,
‘automatic_serialization’ => true
);

$back = array(
‘cache_dir’ => APPLICATION_PATH . ‘/../cache’
);

$cache = Zend_Cache::factory(‘Core’, ‘File’, $front, $back);

Zend_Registry::set(‘cache’, $cache);
}
}

For caching to work correctly, I had to create the ‘cache’ folder in my site root. Notice I set a cache lifetime in my bootstrap, I’ll be overriding it later for my twitter service. I like to set a general lifetime when caching and override the items that I believe need a different lifetime value.

Twitter Service

Next was creating my twitter service. I added a folder ‘service’ under ‘application’ and created a file called ‘Twitter.php’. Here is the content for that file:

class My_Service_Twitter
{
const CACHELIFETIME = 3600;

protected $_screen_name = null;
protected $_cache = null;

public function __construct($screen_name)
{
$this->_screen_name = $screen_name;

$this->_cache = Zend_Registry::get(‘cache’);
}

public function getUserTimeline($count)
{
$cache_id = ‘twitter_’ . $this->_screen_name . $count;

if(!($data = $this->_cache->load($cache_id)))
{
$client = new Zend_Rest_Client(‘http://twitter.com/statuses/user_timeline.xml’);

// setup params for service call
$client->screen_name($this->_screen_name);
$client->count($count);

// call service and get all data
$raw_data = $client->get();

// create array with the data we want – text is the actual tweet 140 chars
$data = array();
if(!isset($raw_data->error))
{
foreach($raw_data->status as $tweet)
{
$data[][‘text’] = (string)$tweet->text;
}
}

// save array to cache – override cache lifetime
$this->_cache->save($data, $cache_id, array(‘twitter’), self::CACHELIFETIME);
}

return $data;
}
}

Let me explain what I’m doing here. First I setup some variables. I setup the cache lifetime var to an hour since I don’t want to be hitting twitter to often and I don’t tweet more than a couple times a day anyways. In the construct, I simply set my class properties. Twitter API has various service calls you can make. For the purpose of this app, I simply want to return the last 50 tweets posted by a public user – me. If you look at the twitter docs, you’ll see statuses user_timeline will give us just that. The call to the service is very simple. We create a Zend_Rest_Client instance to the service url: http://twitter.com/statuses/user_timeline.xml. Then we setup both parameters (check the link to the twitter api to see the rest of the available params) screen name (the twitter account you are looking for) and count (how many tweets to get back) and call $client->get(). When I get the raw data from twitter, I create an array storing only the data I need which is text (the actual content of your tweets 140 characters).

Easy enough? I thought so. You’ll also notice that this functionality is wrapped with caching code. Before calling the service, I check to see if this information is already cached and valid. If so, I just return the cached array else I call the service and store the array in cache. More info my Zend_Cache post on how Zend_Cache works.

IndexController

Next I added the following call to my IndexController:

public function indexAction()
{
// needed vars
$screen_name = ‘joeyrivera’;
$total_tweets = 50;
$tweets_per_page = 10;

// get tweets
$service = new My_Service_Twitter($screen_name);
$data = $service->getUserTimeline($total_tweets);

// init paginator
$paginator = Zend_Paginator::factory($data);
$paginator->setItemCountPerPage($tweets_per_page)
->setCurrentPageNumber($this->_getParam(‘page’, 1));

// send paginator to view
$this->view->paginator = $paginator;
}

I started by setting up required params. Then initializing My_Service_Twitter and calling the getUserTimeline method.$data gets all 50 tweets from Twitter through Zend_Rest_Client or loaded straight from the cache. Last few steps are calling Zend_Paginator::factory and passing in the $data array of tweets. The next line sets the number of items we want displayed per page and sets the current page number – the page querystring variable (more options here). This last part will make sense soon when I show you the pagination.phtml (the actual pagination controls) file that renders the page numbers and previous/next links in the view. Since we are done with our paginator var, we pass it to our view to display.

Index View

The view is pretty simple, all it does is display the list of tweets, 10 tweets per page. It also needs to display the pagination controls which is the file I mentioned earlier. Here is the index.phtml file:

< ?php if (count($this->paginator)): ?>

foreach

(

$this

paginator

$item

)

< ?php echo $item[‘text’]; ?>

endforeach

< ?php endif; ?>

< ?php echo $this->paginationControl($this->paginator, ‘Sliding’, ‘pagination.phtml’); ?>

If any items are found, the loop takes place and the items are displayed in the list. Zend_Paginator takes care of handling how many items to show and for what page using that parameters we setup earlier. The last line is important. There are different styles you can use when displaying your pagination such as ‘sliding’, ‘jumping’, ‘elastic’ and more. You can read about them all in the zend docs. ‘pagination.phtml’ is the file used to display the page numbers and next/previous links. This file can be made so it’s reusable across your application and you can customize it anyway you like.

Pagination.phtml

Here is my file which is located in my views/scripts/ folder:

if($this->pageCount == 1)
{
return;
}

// previous
if(isset($this->previous))
{
echo ‘$this->url(array(‘page’ => $this->previous)).‘">< Previous ‘;
}
else
{
echo ‘< Previous ‘; } // pages foreach($this->pagesInRange as $page)
{
if($page != $this->current)
{
echo ‘ $this->url(array(‘page’ => $page)).‘">’.$page.‘ ‘;
}
else
{
echo ‘ ‘, $page, ‘ ‘;
}
}

// next
if(isset($this->next))
{
echo ‘ $this->url(array(‘page’ => $this->next)).‘">Next >’;
}
else
{
echo ‘ Next >’;
}

If there is only 1 page, do nothing else display the page numbers and if there is a previous or next page, display those links as well. Notice I’m setting a page variable to add to my querystring. This is so Zend_Paginator knows what page I’m currently at and can display the correct items. For example: ‘www.myapp.com/index/index/’ would default to page one. ‘www.myapp.com/index/index/page/3′ would let paginator know we want to display the items that belong to page 3. It also lets the pagination.phtml file know if there is a page 2 and/or 4 to display a back and previous link.

Here is a image of the end result:

Final Thoughts

That’s pretty much it. Hopefully I’m not forgetting anything. Notice I don’t have any filtering/validating anywhere. I just wrote this quickly to give a basic understanding on how to use these modules together. I think I’m going to update my ‘Interesting Images’ and ‘Interesting Links’ widgets on my sidebar to use pagination and allow users to view older entries.

Something to keep in mind for optimization purposes. Depending on where you are getting your data and how much data you want, it makes more sense to get a total number of items to get an idea of how many pages you need (not get all the data at once!). Then for each page you can get the data that needs to be displayed. For example, I would never call twitter and say: bring back my last one thousand tweets just so I can display 10 on a page and one hundred page numbers. That would be an extreme waste of resources. Instead, I could ask Twitter: how many tweets do I have in total which is all I need to draw my pagination. Then for each page, I can download the data I need and display.

Feel free to leave any questions or comments!

EDIT: Created new post on using Twitter API and OAuth.