twitter_signin_oauth_three_legged.py

from hashlib import sha1
import hmac
import base64
import time
import random
import sys
import collections
import ConfigParser
import urllib
import random
import base64
import hmac
import binascii
import time
import collections
import hashlib
import requests
import json
import treq


def formatGenericError(error,message=''):
    return {
        "errors" : [error],
        "message" : message,
        "success" : False
    }

def genericErrback(f, msg_body=''):
    msg = formatGenericError(
        error=str(f.getTraceback(),),
        message=msg_body
    )
    log.msg(json.dumps(msg),level=logging.ERROR)


class OAuthHandler(object):
    def __init__(self, access_token, access_token_secret):
        pass

    def handle_response(self, content):
        print "########################"
        print content
        print "########################"
        return str(content)
    
    def collect_response(self, response):
        d = response.content()
        d.addCallback(self.handle_response)

    def escape(self, s):
        """Percent Encode the passed in string"""
        return urllib.quote(s, safe='~')

    def create_signing_key(self, oauth_consumer_secret, oauth_token_secret=None):
        """Create key to sign request with"""
        signing_key = self.escape(oauth_consumer_secret) + '&'
        if oauth_token_secret is not None:
            signing_key += self.escape(oauth_token_secret)
        return signing_key

    def collect_parameters(self, oauth_parameters, status, url_parameters):
        """Combines oauth, url and status parameters"""
        #Add the oauth_parameters to temp hash
        temp = oauth_parameters.copy()
        #Add the status, if passed in.  Used for posting a new tweet
        if status is not None:
            temp['status'] = status
        #Add the url_parameters to the temp hash
        for k, v in url_parameters.iteritems():
            temp[k] = v

        return temp

    def get_nonce(self):
        """Unique token generated for each request"""
        n = base64.b64encode(
            ''.join([str(random.randint(0, 9)) for i in range(24)]))
        return n

    def get_oauth_parameters(self, consumer_key, access_token, callback_url):
        """Returns OAuth parameters needed for making request"""
        oauth_parameters = {
            'oauth_timestamp': str(int(time.time())),
            'oauth_signature_method': "HMAC-SHA1",
            'oauth_version': "1.0",
            'oauth_token': access_token,
            'oauth_nonce': self.get_nonce(),
            'oauth_callback':urllib.quote(callback_url),
            'oauth_consumer_key': consumer_key
        }
        return oauth_parameters

    def calculate_signature(self, signing_key, signature_base_string):
        """Calculate the signature using SHA1"""
        hashed = hmac.new(signing_key, signature_base_string, hashlib.sha1)
        sig = binascii.b2a_base64(hashed.digest())[:-1]
        return self.escape(sig)

    def create_auth_header(self, parameters):
        """For all collected parameters, order them and create auth header"""
        ordered_keys = [
            'oauth_nonce', 'oauth_callback', 'oauth_signature_method', 'oauth_timestamp', \
            'oauth_consumer_key', 'oauth_signature', 'oauth_version'
        ]
        ordered_parameters = collections.OrderedDict()
        for key in ordered_keys:
            ordered_parameters[key] = parameters[key]
        auth_header = (
            '%s="%s"' % (k, v) for k, v in ordered_parameters.iteritems())
        val = "OAuth " + ', '.join(auth_header)
        return val
    
    def stringify_parameters(self, parameters):
        """Orders parameters, and generates string representation of parameters"""
        output = ''
        ordered_parameters = {}
        ordered_parameters = collections.OrderedDict(sorted(parameters.items()))

        counter = 1
        for k, v in ordered_parameters.iteritems():
            output += self.escape(str(k)) + '=' + self.escape(str(v))
            if counter < len(ordered_parameters):
                output += '&'
                counter += 1
        return output
    
    def generate_signature(self, method, url, url_parameters, oauth_parameters,
                           oauth_consumer_key, oauth_consumer_secret,
                           oauth_token_secret=None, status=None):
        """Create the signature base string"""
        #Combine parameters into one hash
        #temp = collect_parameters(oauth_parameters, status, url_parameters)
        temp = self.collect_parameters(oauth_parameters, status, url_parameters)
        #Create string of combined url and oauth parameters
        parameter_string = self.stringify_parameters(temp)
        #Create your Signature Base String
        signature_base_string = (
            method.upper() + '&' +
            self.escape(str(url)) + '&' +
            self.escape(parameter_string)
        )
        #Get the signing key
        signing_key = self.create_signing_key(oauth_consumer_secret, oauth_token_secret)
        return self.calculate_signature(signing_key, signature_base_string)
    
    
    def __call__(self):
        config = ConfigParser.RawConfigParser()
        config.read('/home/vagrant/projects/foodies/env/src/foodie.web/src/foodie/web/login/settings.cfg')
        method = 'POST'
        url = 'https://api.twitter.com/oauth/request_token'
        callback_url = 'http://mysite.com/twitter_callback'
        url_parameters = {}
        body_parameters = {'oauth_callback':callback_url}
        body_parameters = {}
        
        keys = {
            "twitter_consumer_secret": config.get('Keys', 'twitter_consumer_secret'),
            "twitter_consumer_key": config.get('Keys', 'twitter_consumer_key'),
            "access_token": config.get('Keys', 'access_token'),
            "access_token_secret": config.get('Keys', 'access_token_secret')
        }
        
        oauth_parameters = self.get_oauth_parameters(
            keys['twitter_consumer_key'],
            keys['access_token'],
            callback_url
        )
        
        oauth_parameters['oauth_signature'] = self.generate_signature(
            method,
            url,
            url_parameters, oauth_parameters,
            keys['twitter_consumer_key'],
            keys['twitter_consumer_secret'],
            keys['access_token_secret']
        )
        
        headers = {'Authorization': self.create_auth_header(oauth_parameters)} 
        
        body_parameters = urllib.urlencode(body_parameters)
        d = treq.post(
            url,
            json.dumps(body_parameters),
            headers=headers
        )
        d.addCallback(self.collect_response)
        d.addErrback(genericErrback)