keakon的涂鸦馆

1. Consumer向Service Provider请求Request Token
   
2. Service Provider验证后返回未授权的Request Token
   
3. Consumer将User跳转到Service Provider，让其同意授权
   
4. Service Provider接到User的授权许可后，将User重定向到Consumer
   
5. Consumer在用户跳转回来后拿到已授权的Request Token，再次向Service Provider请求Access Token
   
6. Service Provider验证已授权的Request Token，向Consumer提供Access Token
   
7. Consumer使用Access Token，访问User的资源
   

CONSUMER_KEY = ...
CONSUMER_SECRET = ...

HOME_URL = 'http://keakon.appspot.com/twitter/'
#CALLBACK_URL = 'http://localhost:8080/twitter/callback' # 这个是用于本地测试的，改成下面的或者设为''就使用默认回调地址
CALLBACK_URL = 'http://keakon.appspot.com/twitter/callback'
REQUEST_TOKEN_URL = 'https://api.twitter.com/oauth/request_token'
ACCESS_TOKEN_URL = 'https://api.twitter.com/oauth/access_token'
AUTHORIZE_URL = 'https://api.twitter.com/oauth/authorize'

import logging
from urllib import quote, urlencode
import hmac
from hashlib import sha1
from random import getrandbits
from time import time

from google.appengine.api import xmpp, urlfetch, users, memcache
from google.appengine.ext import webapp, db
from google.appengine.ext.webapp.util import run_wsgi_app
from google.appengine.ext.webapp.xmpp_handlers import CommandHandler

application = webapp.WSGIApplication([
  ('/_ah/xmpp/message/chat/', XMPPHandler),
  ('/twitter/', TwitterStatus),
  ('/twitter/oauth', TwitterOauth),
  ('/twitter/callback', TwitterCallback)
])

class Twitter(db.Model):
  token = db.StringProperty(indexed=False)
  secret = db.StringProperty(indexed=False)


class TwitterStatus(webapp.RequestHandler):
  def get(self):
    email = users.get_current_user().email()
    twitter = Twitter.get_by_key_name(email)
    # 然后判断twitter是否能取到，输出状态信息即可。当然也别忘了加上TwitterOauth的链接。

def qt(s):
  return quote(s, '~')

def get_oauth_params(params, base_url, token_secret='', callback_url=CALLBACK_URL, method='POST'):
  default_params = {
    'oauth_consumer_key': CONSUMER_KEY,
    'oauth_signature_method': 'HMAC-SHA1',
    'oauth_timestamp': str(int(time())),
    'oauth_nonce': hex(getrandbits(64))[2:], # 生成64位的随机数
    'oauth_version': '1.0'
  } # 这些是都需要用到的通用参数，而params是特定参数

  params.update(default_params)

  if callback_url: # 没有callback_url时就不加，会使用默认回调地址
    params['oauth_callback'] = qt(callback_url)

  keys = sorted(list(params.keys()))
  encoded = qt('&'.join(['%s=%s' % (key, params[key]) for key in keys]))
  # 连接成'key1=value1&key2=value2'的转义后的形式，且key经过了排序

  base_string = '%s&%s&%s' % (method, qt(base_url), encoded) # 拼接base string
  key = CONSUMER_SECRET + '&' + token_secret # 注意token_secret可能为''，这也不要紧，'&'必须要有

  params['oauth_signature'] = qt(hmac.new(key, base_string, sha1).digest().encode('base64')[:-1]) # 看上去挺复杂的签名，看不懂就照抄吧

  return params

def qs2dict(s): # 这个函数是把'key1=value1&key2=value2'转换成字典对象
  dic = {}
  for param in s.split('&'):
    (key, value) = param.split('=')
    dic[key] = value
  return dic

def dict2qs(dic): # 这个函数是把字典对象转换成'key1="value1", key2="value2"'的形式
  return ', '.join(['%s="%s"' % (key, value) for key, value in dic.iteritems()])

class TwitterOauth(webapp.RequestHandler):
  def get(self):
    params = get_oauth_params({}, REQUEST_TOKEN_URL)
    res = urlfetch.fetch(url=REQUEST_TOKEN_URL, headers={'Authorization': 'OAuth ' + dict2qs(params)}, method='POST')
    # OAuth参数需要放在Authorization头字段里
    if res.status_code != 200:
      logging.error('Fetch request token error.\n%s\n%s\n%s' % (res.status_code, res.headers, params))
      self.response.out.write('获取request token失败，可能是Google App Engine或Twitter出现了问题，请稍后再试。')
      return

    dic = qs2dict(res.content) # 拿到oauth_token和oauth_token_secret
    if dic['oauth_callback_confirmed'] != 'true': # 成功的话会有oauth_callback_confirmed=true，没有的话说明失败了
      logging.error('Request token param error.\n%s\n%s\n%s' % (res.status_code, res.headers, params))
      self.response.out.write('获取request token失败，可能是Google App Engine或Twitter出现了问题，请稍后再试。')
      return

    memcache.set(dic['oauth_token'], dic['oauth_token_secret'], 600, namespace='TwitterRequestToken')
    # 临时存储一下oauth_token和oauth_token_secret，用户回来时还会用到；如果想要更保险的话，可以使用数据库来取代memcache
    self.redirect('%s?oauth_token=%s' % (AUTHORIZE_URL, dic['oauth_token'])) # 将用户跳转到Service Provider

class TwitterCallback(webapp.RequestHandler):
  def get(self):
    request = self.request
    oauth_token = request.get('oauth_token') # 从回调链接获取oauth_token
    if not oauth_token:
      logging.error('Missing oauth_token:' + oauth_token)
      self.response.out.write('交换access token失败，缺少oauth_token，请返回重试。')
      return

    oauth_token_secret = memcache.get(oauth_token, 'TwitterRequestToken') # 在memcache里根据oauth_token取回oauth_token_secret 
    if not oauth_token_secret:
      logging.error('Missing or wrong oauth_token:' + oauth_token)
      self.response.out.write('交换access token失败，可能是oauth_token无效或已过期，请重试。')
      return

    params = get_oauth_params({ # 这次要用到2个新参数，刚才已经获取了
      'oauth_token': oauth_token,
      'oauth_verifier': request.get('oauth_verifier')
    }, ACCESS_TOKEN_URL, oauth_token_secret) # oauth_token_secret也已经拿到了，也要加进来

    res = urlfetch.fetch(url=ACCESS_TOKEN_URL, headers={'Authorization': 'OAuth ' + dict2qs(params)}, method='POST')
    if res.status_code != 200:
      logging.error('Exchanging access token error.\n%s\n%s\n%s' % (res.status_code, res.headers, params))
      self.response.out.write('交换access token失败，可能是Google App Engine或Twitter出现了问题，请稍后再试。')
      return

    dic = qs2dict(res.content) # 拿到oauth_token和oauth_token_secret，实际上还有用户的Twitter名和ID，不过我们用不到
    Twitter(key_name=users.get_current_user().email(), token=dic['oauth_token'], secret=dic['oauth_token_secret']).put() # 保存到数据库以备以后使用

    # 然后告诉用户关联成功即可

RESOURCE_URL = 'https://api.twitter.com/1/statuses/update.json'

class XMPPHandler(CommandHandler):
  def text_message(self, message):
    email = message.sender.split('/')[0] # sender的格式是"邮箱地址/数字ID"，只取第一部分的邮箱；由于Google Talk也是用Google账号登录，所以可以通用
    twitter = Twitter.get_by_key_name(email)
    if not twitter:
      message.reply('您的Google账号还没有与Twitter账号关联，请先去 %s 关联' % HOME_URL)
      return

    if len(message.body) > 140:
      message.reply('您发的推超过140字，请精简后再发送')
      return

    msg = message.body.encode('UTF-8') # 注意要编码成UTF-8

    params = get_oauth_params({
      'oauth_token': twitter.token,
      'status': qt(msg) # 后面的Authorization还得转义一次，相当于转义了2次
    }, RESOURCE_URL, twitter.secret, '') # 这里的token和secret是从数据库里取出来的

    del params['status'] # 删掉status，避免在Authorization里生成，实际上可以修改get_oauth_params的实现，自动删除这些字段

    res = urlfetch.fetch(url=RESOURCE_URL, payload=urlencode({'status': msg}), headers={'Authorization': 'OAuth ' + dict2qs(params)}, method='POST') # payload需要urlencode
    if res.status_code != 200:
      logging.error('Access resource error.\n%s\n%s\n%s' % (res.status_code, res.headers, params))
      message.reply('访问Twitter出错，可能是Google App Engine或Twitter出现了问题，请稍后再试。')
      return

    message.reply('发送成功')