def get(self):
#print os.environ["HTTP_HOST"]
#print os.environ['REMOTE_ADDR']
callback_url = "http://%s:8080/" % os.environ["REMOTE_ADDR"]
"""for k, v in os.environ.items():
print "%s=%s" % (k,v)"""
client = oauth.TwitterClient(CONSUMER_KEY, CONSUMER_SECRET_KEY, None)
m = self.request.get("m")
type = self.request.get("type")
message = m
param = {'status': message}
message = urllib.quote(message.encode("utf-8"))
if (m != "" and type == "update"):
try:
res = client.make_request(
'http://api.twitter.com/1/statuses/update.json',
token=ACCESS_TOKEN,
secret=ACCESS_TOKEN_SECRET,
additional_params=param,
method='POST')
except Exception, e:
logging.error(e)
if res.status_code != 200:
logging.warning('Failed to post a message to twitter. status_code: %d' \
% res.status_code)
self.response.out.write('Error Status:' + res.status_code)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(res.content)
def post(self, mode=''):
callback_url = "%s/oauth/verify" % self.request.host_url
client = oauth.TwitterClient(CONSUMER_KEY, CONSUMER_SECRET,
callback_url)
if mode == 'changekey':
screen_name = self.request.get("name")
old_key = self.request.get("old_key")
new_key = self.request.get("new_key")
user_access_token, user_access_secret = client.get_access_from_db(
screen_name, old_key)
if user_access_token is None or user_access_secret is None:
logging.debug("screen_name:" + screen_name)
logging.debug("old_key:" + old_key)
logging.debug("new_key:" + new_key)
self.response.out.write(
'Can not find user from db, or invalid old_key.')
else:
try:
client.save_user_info_into_db(username=screen_name,
password=new_key,
token=user_access_token,
secret=user_access_secret)
show_key_url = '%s/oauth/showkey?name=%s&key=%s' % (
self.request.host_url, screen_name, new_key)
self.redirect(show_key_url)
except Exception, error_message:
logging.debug("screen_name:" + screen_name)
logging.debug("old_key:" + old_key)
logging.debug("new_key:" + new_key)
logging.debug(error_message)
self.response.out.write(error_message)
def post(self):
self.response.headers['Content-Type'] = 'text/html'
client = oauth.TwitterClient(dc.keys["twitter"]["CONSUMER_KEY"],
dc.keys["twitter"]["CONSUMER_SECRET_KEY"],
None)
cs = CloudSQL(instance='dajaremockupdb:dajare1242',
database='dajare1242')
id = self.request.cookies.get("dajare1242_id", "").encode("utf-8")
user = cs.select(table='userdb', column='*', option='WHERE id=%s' % id)
access_token = user[0][3]
access_token_secret = user[0][4]
message = self.request.get("tw")
if message is "":
self.redirect("/")
param = {'status': message}
tweet = cs.select(table='user_tweet',
column='*',
option='WHERE uid="%s" AND tweet="%s"' %
(id.encode("utf-8"), message.encode("utf-8")))
if str(len(tweet)) == "0":
data = (id.encode("utf-8"), message.encode("utf-8"))
cs.insert(column=("uid", "tweet"), data=data)
res = client.make_request(
'http://api.twitter.com/1/statuses/update.json',
token=access_token,
secret=access_token_secret,
additional_params=param,
method='POST')
else:
self.response.out.write('投稿済み')
self.redirect("/")
def get(self):
cs = CloudSQL(instance='dajaremockupdb:dajare1242',
database='dajare1242')
self.response.headers['Content-Type'] = 'text/html'
callback_url = "http://%s/oauth_callback" % (os.environ["HTTP_HOST"])
id = self.request.cookies.get("dajare1242_id", "").encode("utf-8")
q = self.request.get("q")
p = self.request.get("p")
prefix = "dajare1242_"
expires = 60 * 60 * 24
self.response.headers.add_header(
'Set-Cookie', '%s=%s; expires=%s; PATH=/;' %
(prefix + "redirect_uri", '/', expires))
tv = {}
tv["signin"] = 0
client = None
if id == "":
client = oauth.TwitterClient(
dc.keys["twitter"]["CONSUMER_KEY"],
dc.keys["twitter"]["CONSUMER_SECRET_KEY"], callback_url)
else:
tv["signin"] = 1
tv["id"] = id
tv["user_tmp"] = cs.select(table='userdb',
column='*',
option='WHERE id="%s"' % str(tv["id"]))
tv["user"] = tv["user_tmp"][0]
if client is not None:
tv["oauthUrl"] = client.get_authorization_url()
if q is "":
if len(os.environ["PATH_INFO"].split("/")) == 3:
q = os.environ["PATH_INFO"].split("/")[3]
#print len(os.environ["PATH_INFO"].split("/"))
#
if p is "":
p = "1"
# self.response.out.write(q)
url = "http://dajare-api.appspot.com/find/?size=100&keyword=" + q + "&page=" + p
"""
POSTのみ対応、また
"""
t = urlfetch.fetch(url=url)
j = simplejson.loads(t.content)
page = 0
if j["allTotal"] is not 0 and j["total"] is not 0:
page = j["allTotal"] / j["total"]
tv["json"] = j
tv["words"] = urllib2.unquote(q)
tv["allTotal"] = j["allTotal"]
tv["page"] = range(page)
#self.response.out.write(page)
# http://http://dajare-api.appspot.com/?page=1&size=20
tmpl_path = os.path.dirname(__file__) + "/tmpl/"
path = os.path.join(tmpl_path, 'search.tmp')
# self.response.out.write(template.render(path, []))
self.response.out.write(template.render(path, tv))
def twitter_request(request):
"""
Login or signup a user with twitter.
"""
consumer_key = settings.TWITTER_CONSUMER_KEY
consumer_secret = settings.TWITTER_CONSUMER_SECRET
callback_url = settings.TWITTER_CALLBACK
client = oauth.TwitterClient(consumer_key, consumer_secret, callback_url)
return redirect(client.get_authorization_url())
def try_request(url='http://api.twitter.com/1/statuses/friends_timeline.json'):
"""Send request to twitter url"""
# request.content holds json response
# request.headers holds http headers
client = oauth.TwitterClient(CONSUMER_KEY, CONSUMER_SECRET, CALLBACK_URL)
result = client.make_request(url, token=USER_TOKEN, secret=USER_SECRET,
additional_params=None, method=urlfetch.GET)
return json.loads(result.content)
def twitter_signin(request):
"""Signin a user through twitter."""
consumer_key = settings.TWITTER_CONSUMER_KEY
consumer_secret = settings.TWITTER_CONSUMER_SECRET
callback_url = settings.TWITTER_CALLBACK
if request.user.is_authenticated():
return redirect(settings.LOGIN_REDIRECT_URL)
client = oauth.TwitterClient(consumer_key, consumer_secret, callback_url)
return redirect(client.get_authenticate_url())
def get(self):
cs = CloudSQL(instance='dajaremockupdb:dajare1242',
database='dajare1242')
self.response.headers['Content-Type'] = 'text/html'
callback_url = "http://%s/oauth_callback" % (os.environ["HTTP_HOST"])
id = self.request.cookies.get("dajare1242_id", "").encode("utf-8")
prefix = "dajare1242_"
expires = 60 * 60 * 24
self.response.headers.add_header(
'Set-Cookie', '%s=%s; expires=%s; PATH=/;' %
(prefix + "redirect_uri", urllib2.quote(
os.environ["PATH_INFO"]), expires))
# print self.request.cookies.get("dajare1242_redirect_uri", "").encode("utf-8")
"""
for k, v in os.environ.items():
print "%s=%s" % (k,v)
"""
client = None
user = None
tv = {}
tv["signin"] = 0
if id == "":
client = oauth.TwitterClient(
dc.keys["twitter"]["CONSUMER_KEY"],
dc.keys["twitter"]["CONSUMER_SECRET_KEY"], callback_url)
else:
tv["signin"] = 1
tv["id"] = id
tbl = 'userdb'
tv["user_tmp"] = cs.select(table=tbl,
column='*',
option='WHERE id="%s"' % str(tv["id"]))
tv["user"] = tv["user_tmp"][0]
if client is not None:
tv["oauthUrl"] = client.get_authorization_url()
pid = None
#id=self.request.get("id")
if pid is None:
pid = os.environ["PATH_INFO"].split("/")[2]
url = "http://dajare-api.appspot.com/find/" + pid
t = urlfetch.fetch(url=url)
j = simplejson.loads(t.content)
tv["invild_flag"] = False
if type(j["results"]) is types.DictionaryType:
tv["json"] = j["results"]
tv["invild_flag"] = True
tv["host"] = "http://%s%s" % (os.environ["HTTP_HOST"],
os.environ["PATH_INFO"])
tv["fb"] = urllib2.unquote(tv["host"])
tmpl_path = os.path.dirname(__file__) + "/tmpl/"
fileName = 'frame.tmp'
path = os.path.join(tmpl_path, fileName)
self.response.out.write(template.render(path, tv))
def get(self, mode=""):
callback_url = "%s/oauth/verify" % self.request.host_url
client = oauth.TwitterClient(CONSUMER_KEY, CONSUMER_SECRET, callback_url)
if mode=='session':
# step C Consumer Direct User to Service Provider
try:
url = client.get_authorization_url()
self.redirect(url)
except Exception,error_message:
self.response.out.write( error_message )
def do_proxy(self, method):
orig_url = self.request.url
orig_body = self.request.body
new_url, new_path = self.conver_url(orig_url)
if new_path == '/' or new_path == '':
user = users.get_current_user()
if user == None:
self.redirect(users.create_login_url('/'))
else:
if not users.is_current_user_admin():
self.error(403)
path = os.path.join(os.path.dirname(__file__), '403.html')
self.response.out.write(template.render(path, {}))
return
else:
global gtap_message
gtap_message = gtap_message.replace(
'#gtap_version#', gtap_version)
return success_output(self, gtap_message)
username, password = self.parse_auth_header(self.request.headers)
user_access_token = None
consumer_key, consumer_secret = oauth.get_consumer_info()
callback_url = "%s/oauth/verify" % self.request.host_url
client = oauth.TwitterClient(consumer_key, consumer_secret,
callback_url)
if username is None:
protected = False
user_access_token, user_access_secret = '', ''
else:
protected = True
user_access_token, user_access_secret = client.get_access_from_db(
username, password)
if user_access_token is None:
return error_output(self, 'Can not find this user from db')
additional_params = dict([(k, v) for k, v in parse_qsl(orig_body)])
use_method = urlfetch.GET if method == 'GET' else urlfetch.POST
try:
data = client.make_request(url=new_url,
token=user_access_token,
secret=user_access_secret,
method=use_method,
protected=protected,
additional_params=additional_params)
except Exception, error_message:
logging.debug(error_message)
error_output(self, content=error_message)
def twit(message):
"""
Отправляет в твиттер произвольное сообщение.
"""
client = oauth.TwitterClient(config.TWITTER_CONSUMER_KEY,
config.TWITTER_CONSUMER_SECRET,
'http://%s/verify' % config.HOSTNAME)
result = client.make_request('http://twitter.com/statuses/update.json',
token=config.TWITTER_ACCESS_TOKEN_KEY,
secret=config.TWITTER_ACCESS_TOKEN_SECRET,
additional_params={'status': message},
method=urlfetch.POST)
def authenticate(self, auth_token=None, auth_verifier=None):
import oauth
consumer_key = settings.TWITTER_CONSUMER_KEY
consumer_secret = settings.TWITTER_CONSUMER_SECRET
callback_url = settings.TWITTER_CALLBACK
client = oauth.TwitterClient(consumer_key, consumer_secret,
callback_url)
user_info = client.get_user_info(auth_token,
auth_verifier=auth_verifier)
return self.user_from_info(self._parse_info(user_info))
def get(self):
cs = CloudSQL(instance='dajaremockupdb:dajare1242',
database='dajare1242')
(oauth_token, oauth_verifier) = (self.request.get("oauth_token"),
self.request.get("oauth_verifier"))
if self.request.get("denied") is not "":
#print self.request.get("denied")
self.redirect("/")
return False
client = oauth.TwitterClient(dc.keys["twitter"]["CONSUMER_KEY"],
dc.keys["twitter"]["CONSUMER_SECRET_KEY"],
None)
user_info = client.get_user_info(oauth_token, oauth_verifier)
prefix = "dajare1242_"
self.response.headers.add_header(
'Set-Cookie', '%s=%s;' % (prefix + "id", user_info["id"]))
#cs.create('userdb', ['user_name VARCHAR(255)', 'service VARCHAR(255)', 'picture TEXT', 'token TEXT', 'secret TEXT', 'id VARCHAR(255)'])
op = 'WHERE id="%s"' % user_info["id"]
tbl = 'userdb'
user = cs.select(table=tbl, column='*', option=op)
#self.response.out.write(user)
#return False
if str(len(user)) is "0":
# Add User
data = (user_info["username"], user_info["service"],
user_info["picture"], user_info["token"],
user_info["secret"], str(user_info["id"]))
cs.insert(column=("user_name", "service", "picture", "token",
"secret", "id"),
data=data)
elif str(len(user)) is "1":
'''
Update Profile
'''
sql = cs.update(column=["user_name", "token", "secret"],
data=[
user_info["username"], user_info["token"],
user_info["secret"]
],
option=' WHERE id="%s"' % (str(user_info["id"])))
AuthTokenDelete()
uri = self.request.cookies.get("dajare1242_redirect_uri", "")
#print uri
if uri is not "":
search_word = self.request.cookies.get("dajare1242_search_word",
"")
if search_word is not "":
uri = uri + '?q=' + search_word
self.redirect(uri)
else:
self.redirect("/")
def _doTweet(self, masterData, botData):
import oauth
client = oauth.TwitterClient(masterData.cKey,
masterData.cSecret, None)
run_on_appengine(client, store_tokens=False, single_user_mode=True)
param = {'status': botData.status}
client.make_request('https://api.twitter.com/1.1/statuses/update.json',
token=masterData.aToken,
secret=masterData.aTokenSecret,
additional_params=param,
protected=True,
method='POST')
logging.info(botData.status)
def get(self):
consumer_key = self.request.get("consumer_key", default_value="")
consumer_secret = self.request.get("consumer_secret", default_value="")
access_token = self.request.get("access_token", default_value="")
secret_token = self.request.get("secret_token", default_value="")
count = self.request.get("count", default_value="200")
client = oauth.TwitterClient(consumer_key, consumer_secret, "oob")
respuesta = client.make_request(
"https://api.twitter.com/1.1/statuses/home_timeline.json",
token=access_token, secret=secret_token,additional_params={"count": count}, protected=True)
self.response.write(respuesta.content)
def get(self):
consumer_key = self.request.get("consumer_key", default_value="")
consumer_secret = self.request.get("consumer_secret", default_value="")
access_token = self.request.get("access_token", default_value="")
secret_token = self.request.get("secret_token", default_value="")
count = self.request.get("count", default_value="200")
client = oauth.TwitterClient(consumer_key, consumer_secret, "oob")
respuesta = client.make_request(
"https://api.twitter.com/1.1/statuses/home_timeline.json",
token=access_token,
secret=secret_token,
additional_params={"count": count},
protected=True)
self.response.headers.add_header('Access-Control-Allow-Origin', '*')
self.response.headers['Content-Type'] = 'application/json'
self.response.write(respuesta.content)
def get(self):
consumer_key = self.request.get('consumer_key', default_value='')
consumer_secret = self.request.get('consumer_secret', default_value='')
access_token = self.request.get('access_token', default_value='')
secret_token = self.request.get('secret_token', default_value='')
count = self.request.get('count', default_value='20')
client = oauth.TwitterClient(consumer_key, consumer_secret, 'oob')
respuesta = \
client.make_request('https://api.twitter.com/1.1/statuses/home_timeline.json'
, token=access_token,
secret=secret_token,
additional_params={'count': count},
protected=True)
self.response.headers.add_header('Access-Control-Allow-Origin', '*')
self.response.headers['Content-Type'] = 'application/json'
self.response.write(respuesta.content)
def do_proxy(self, method):
orig_url = self.request.url
orig_body = self.request.body
new_url, new_path = self.convert_url(orig_url)
if new_path == '/' or new_path == '':
global gtap_message
gtap_message = gtap_message.replace('#gtap_version#', gtap_version)
return success_output(self, gtap_message)
username, password = self.parse_auth_header(self.request.headers)
user_access_token = None
callback_url = "%s/oauth/verify" % self.request.host_url
client = oauth.TwitterClient(CONSUMER_KEY, CONSUMER_SECRET,
callback_url)
if username is None:
protected = False
user_access_token, user_access_secret = '', ''
else:
protected = True
user_access_token, user_access_secret = client.get_access_from_db(
username, password)
if user_access_token is None:
return error_output(self, 'Can not find this user from db')
additional_params = dict([(k, v) for k, v in parse_qsl(orig_body)])
use_method = urlfetch.GET if method == 'GET' else urlfetch.POST
try:
data = client.make_request(url=new_url,
token=user_access_token,
secret=user_access_secret,
method=use_method,
protected=protected,
additional_params=additional_params)
except Exception, error_message:
logging.debug(error_message)
error_output(self, content=error_message)
def get(self, mode=""):
# Your application Twitter application ("consumer") key and secret.
# You'll need to register an application on Twitter first to get this
# information: http://www.twitter.com/oauth
application_key = "FILL_IN"
application_secret = "FILL_IN"
# Fill in the next 2 lines after you have successfully logged in to
# Twitter per the instructions above. This is the *user's* token and
# secret. You need these values to call the API on their behalf after
# they have logged in to your app.
user_token = "FILL_IN"
user_secret = "FILL_IN"
# In the real world, you'd want to edit this callback URL to point to your
# production server. This is where the user is sent to after they have
# authenticated with Twitter.
callback_url = "%s/verify" % self.request.host_url
client = oauth.TwitterClient(application_key, application_secret,
callback_url)
if mode == "login":
return self.redirect(client.get_authorization_url())
if mode == "verify":
auth_token = self.request.get("oauth_token")
auth_verifier = self.request.get("oauth_verifier")
user_info = client.get_user_info(auth_token,
auth_verifier=auth_verifier)
return self.response.out.write(user_info)
if mode == "timeline":
timeline_url = "http://twitter.com/statuses/user_timeline.xml"
result = client.make_request(url=timeline_url,
token=user_token,
secret=user_secret)
return self.response.out.write(result.content)
self.response.out.write("<a href='/login'>Login via Twitter</a>")
def get(self):
import random
client = oauth.TwitterClient(self.CONSUMER_KEY,
self.CONSUMER_SECRET_KEY, None)
t = urlfetch.fetch(url=self.url)
j = simplejson.loads(t.content)
r = random.randint(1, len(j["results"]) - 1)
str = u"%s %s 「%s」" % (
u"", u"ダジャレで人を幸せにすることを目指し、日々収集中〜 http://goo.gl/KIVPF",
j["results"][r]["text"])
str = str[0:145]
#j["results"][r]["idText"]
param = {'status': str.encode("utf-8")}
res = client.make_request(
'http://api.twitter.com/1/statuses/update.json',
token=self.ACCESS_TOKEN,
secret=self.ACCESS_TOKEN_SECRET,
additional_params=param,
method='POST')
self.response.out.write('')
def get(self):
try:
# Check if the validation was denied
if self.request.get('denied'):
self.redirect("/?denied=True")
return
client = oauth.TwitterClient(config.CONSUMER_KEY,
config.CONSUMER_SECRET,
config.CALLBACK)
authToken = self.request.get("oauth_token")
authVerifier = self.request.get("oauth_verifier")
userInfo = client.get_user_info(authToken,
auth_verifier=authVerifier)
theUserRecord = TwitterUser(key_name=str(userInfo['id']),
username=userInfo['username'],
accessCode=self.getAccessCodeFromToken(
userInfo['token']),
accessToken=userInfo['token'],
accessSecret=userInfo['secret'])
theUserRecord.put()
session = get_current_session()
session.regenerate_id()
session['twitter_user'] = userInfo
session['user_record'] = theUserRecord
self.redirect("/builder")
except Exception as e:
logging.exception(e)
self.response.clear()
self.response.set_status(500)
self.response.out.write("Error validating Twitter's response")
def makeTwitterRequest(self, user, api, params):
# Check if user has been disabled
if user.accessSecret[:8] == 'DISABLED':
self.abort(
403,
detail=
"Your account has been disabled due to quota restrictions. Please contact @Tweet_2_RSS to get reinstated"
)
url = "https://api.twitter.com/1.1/{0}".format(api)
client = oauth.TwitterClient(config.CONSUMER_KEY,
config.CONSUMER_SECRET, config.CALLBACK)
resp = client.make_request(url,
user.accessToken,
user.accessSecret,
additional_params=params,
protected=True)
if resp.status_code == 200:
return json.loads(resp.content)
def get(self):
# Obtención de datos desde fichero en sistema
# fich = open("tweets.json")
# fich = fich.read()
# self.response.write(fich)
#Obtención de datos desde servidor red social
consumer_key = self.request.get("consumer_key", default_value="")
consumer_secret = self.request.get("consumer_secret", default_value="")
access_token = self.request.get("access_token", default_value="")
secret_token = self.request.get("secret_token", default_value="")
count = self.request.get("count", default_value="200")
client = oauth.TwitterClient(consumer_key, consumer_secret, "oob")
respuesta = client.make_request(
"https://api.twitter.com/1.1/statuses/home_timeline.json",
token=access_token,
secret=secret_token,
additional_params={"count": count},
protected=True)
self.response.write(respuesta.content)
def get(self, mode=""):
client = oauth.TwitterClient(CONSUMER_KEY, CONSUMER_SECRET,
"%s/app" % self.request.host_url)
# The /app context displays the main catalog page
if mode == "app":
# Pull out auth token/verifier in order to get an access token
# and in order to get some basic information about the user.
auth_token = self.request.get("oauth_token")
auth_verifier = self.request.get("oauth_verifier")
user_info = client.get_user_info(auth_token,
auth_verifier=auth_verifier)
twitter_username = user_info['username']
# Has a user already used this webapp with twitter_username?
query = User.all().filter("twitter_username ="******"twitter_username ="******"login":
return self.redirect(client.get_authorization_url())
# /purchases is used to allow the user to access their digital goods purchases. When users login (or
# immediately after they complete a purchase), they'll be able to click on a "already purchased" link
# that takes them to the template that they purchased.
elif mode == "purchases":
sid = self.request.get('sid')
if memcache.get(
sid
) is not None: # Without an account reference, we can't credit the purchase
item_id = self.request.get('item_id')
# Verify that the user purchased the item by checking the account information
user_info = memcache.get(sid)
twitter_username = user_info['username']
query = User.all().filter("twitter_username ="******"User %s has not purchased %s" % (
twitter_username,
item_id,
))
self.response.out.write(
render_to_string(
'unknown_error.html', {
'title': 'Invalid Access',
'operation': 'document access'
}))
else:
logging.error("Invalid/expired session in /purchases")
self.response.out.write(
render_to_string('session_expired.html', {
'title': 'Session Expired',
}))
else: # root URL context which is used for setting up the login flow
self.response.out.write(
render_to_string('root.html', {
'title': 'Legal Templates',
}))
def get(self):
cs = CloudSQL(instance='dajaremockupdb:dajare1242',
database='dajare1242')
self.response.headers['Content-Type'] = 'text/html'
url = "http://dajare-api.appspot.com/find/?page=1&size=20"
callback_url = "http://%s/oauth_callback" % (os.environ["HTTP_HOST"])
id = self.request.cookies.get("dajare1242_id", "").encode("utf-8")
prefix = "dajare1242_"
expires = 60 * 60 * 24
self.response.headers.add_header(
'Set-Cookie', '%s=%s; expires=%s; PATH=/;' %
(prefix + "redirect_uri", urllib2.quote(
os.environ["PATH_INFO"]), expires))
client = None
user = None
tv = {}
'''
'''
# http://kizasi.jp/rss.xml
# xml=urlfetch.fetch(url='http://kizasi.jp/rss.xml')
t = {}
j = {}
try:
t = urlfetch.fetch(url=url)
j = simplejson.loads(t.content)
except DeadlineExceededError:
self.response.out.write("DeadlineExceededError")
return False
if len(t.content) <= 1:
return False
tv["json"] = j
tv["signin"] = 0
if id == "":
client = oauth.TwitterClient(
dc.keys["twitter"]["CONSUMER_KEY"],
dc.keys["twitter"]["CONSUMER_SECRET_KEY"], callback_url)
else:
tv["signin"] = 1
tv["id"] = id
op = 'WHERE id="%s"' % (id)
tbl = 'userdb'
tv["user_tmp"] = cs.select(table=tbl, column='*', option=op)
tv["user"] = tv["user_tmp"][0]
if client is not None:
tv["oauthUrl"] = client.get_authorization_url()
#
"""
ランキング処理
"""
url = "http://dajare-api.appspot.com/rank/?page=1&size=5"
t = {}
j = {}
try:
t = urlfetch.fetch(url=url)
j = simplejson.loads(t.content)
results = j["results"][0:10]
j["results"] = results
tv["rank"] = j
except DeadlineExceededError:
self.response.out.write("DeadlineExceededError")
return
#self.response.out.write(results[0:20]["createDate"])
tv["rank"] = j
# self.response.out.write(t.content)
# http://http://dajare-api.appspot.com/?page=1&size=20
tmpl_path = os.path.dirname(__file__) + "/tmpl/"
path = os.path.join(tmpl_path, 'index.tmp')
#self.response.out.write(template.render(path, []))
self.response.out.write(template.render(path, tv))
def get(self):
client = oauth.TwitterClient(config.CONSUMER_KEY,
config.CONSUMER_SECRET, config.CALLBACK)
self.redirect(client.get_authenticate_url())
import urllib
sys.path.insert(0, os.path.dirname(__file__) + '/lib/')
TEMPLATEDIR = os.path.dirname(__file__) + '/template/'
import oauth
import logging
import config
# dev
APPLICATION_KEY = config.APPLICATION_KEY
APPLICATION_SECRET = config.APPLICATION_SECRET
OAUTH_CALLBACK_URL = "%s/oauth/verify" % config.OAUTH_CALLBACK_URL
client = oauth.TwitterClient(APPLICATION_KEY, APPLICATION_SECRET,
OAUTH_CALLBACK_URL)
api_base_url = "http://api.twitter.com/1/"
api_search_url = "http://search.twitter.com/"
class Users(db.Model):
user = db.UserProperty(required=True)
oauth_token = db.StringProperty(required=True) # TextProperty()
oauth_secret = db.StringProperty(required=True) # TextProperty()
onetime_token = db.StringProperty(required=False)
date = db.DateTimeProperty(auto_now_add=True)
setting = db.StringProperty(required=False)
class Error(webapp.RequestHandler):
# -*- coding: utf-8 -*- import sys, os to_add = os.path.join(os.path.dirname(__file__), "astral") sys.path.append(to_add) to_add = os.path.join(os.path.dirname(__file__), "pytz-2012f") sys.path.append(to_add) import oauth import datetime import pytz from astral import * import moonphase_bot.tokens as tokens client = oauth.TwitterClient(tokens.application_key, tokens.application_secret, None) url = 'https://api.twitter.com/1/statuses/update.json' a = Astral() city_name = 'Tokyo' a.solar_depression = 'civil' city = a[city_name] timezone = city.timezone one_day = datetime.timedelta(days=1) tomorrow = datetime.datetime.now() + one_day sun = city.sun(date=datetime.datetime.now(), local=True) sun1 = city.sun(date=tomorrow, local=True) moonphase = a.moon_phase(datetime.datetime.now(), None)
def get(self, mode=""):
client = oauth.TwitterClient(twitter_config.TWITTER_CONSUMER_KEY,
twitter_config.TWITTER_CONSUMER_SECRET,
"%s/app" % self.request.host_url)
# The /app context ensures that the user's account is in good standing in
# terms of payment, computes relevance for tweets from their home timeline,
# stashes the data and serves up the app. The app then requests the stashed
# data via /data.
if mode == "app":
# Pull out auth token/verifier in order to get an access token
# and in order to get some basic information about the user.
# Subsequent requests will be performed via client.make_request
auth_token = self.request.get("oauth_token")
auth_verifier = self.request.get("oauth_verifier")
user_info = client.get_user_info(auth_token,
auth_verifier=auth_verifier)
twitter_username = user_info['username']
# Has a user already used this webapp with twitter_username?
query = User.all().filter("twitter_username ="******"home_timeline":
"http://api.twitter.com/1/statuses/home_timeline.json",
"favorites_timeline":
"http://api.twitter.com/1/favorites.json",
}
# Fetch the first 5 pages of results for the data urls. (More pages could be requested.)
# By default, there are 20 tweets per page for favorites and the home timeline
num_pages = 5
data = {}
for name, url in data_urls.items():
data[name] = []
for page in range(1, num_pages + 1):
result = client.make_request(
url=url,
token=user_info['token'],
secret=user_info['secret'],
additional_params={'page': page})
if result.status_code == 200:
data[name] += json.loads(result.content)
else:
# Could do any number of useful things to actually handle this error
logging.error((
"Expected 200 response but received %d for request "
+ url) % (
result.status_code,
page,
))
# Split out the text of the tweets, remove some leading/trailing punctuation, and filter
# common stopwords
terms = [
self._cleanupTerm(term.lower())
for tweet in data['favorites_timeline']
for term in tweet['text'].split() if self._cleanupTerm(
term.lower()) not in self._getStopwords()
]
# Build a frequency map and sort by value
freqs = {}
for term in terms:
freqs[term] = freqs.get(term, 0) + 1
sorted_terms = sorted(freqs.iteritems(),
key=operator.itemgetter(1),
reverse=True)
# Iterate through each tweet in the home_timeline and assign a relevance score based upon
# the ratio of how many of the top N frequent terms from the favorities appeared in the tweet
n = 200
top_n_terms = set([term for (term, freq) in sorted_terms[:n]])
# Useful for gaining intuition into how the trivial algorithm works
logging.info("\n\nTOP N TERMS FROM FAVORITES:")
logging.info(top_n_terms)
logging.info("\n\n")
for tweet in data['home_timeline']:
tweet_terms = set([
self._cleanupTerm(term.lower())
for term in tweet['text'].split() if self._cleanupTerm(
term.lower()) not in self._getStopwords()
])
num_frequent_terms = len(
tweet_terms.intersection(top_n_terms))
tweet['relevance'] = 1.0 * num_frequent_terms / len(
tweet_terms)
# You could optionally do any number of other things like normalize tweet scores at this point,
# boost relevance scores based upon additional criteria, throw in a random amount of serendipity
# into scores, etc. We'll just be boring and filter out any tweet with a relevance greater than 0.0
# so that only tweets with a relevance of 0.0 or higher are returned in the final response
# The sky is the limit
user_info['relevant_tweets'] = [
tweet for tweet in data['home_timeline']
if tweet['relevance'] > 0
]
# For purposes of not frustrating users of this sample code who don't have any favorites (and would
# hence not have any "relevant tweets", check to make sure at least one relevant tweet exists and
# if it doesn't, just go ahead and assign all tweets as relevant since we have no information to
# otherwise make a decision
if len(user_info['relevant_tweets']) == 0:
user_info['relevant_tweets'] = data['home_timeline']
# Store the ranked tweets as to user_info as "relevant_tweets" and
# stash the latest results from relevance algorithm so the client app can grab them
# from a subsequent request to /data
memcache.set(sid, user_info, time=60 * 10) # seconds
db.put(user)
# Redirect to a mobile client application that will use sid to make a request for the
# tweets we just filtered and stashed away
return self.redirect('/tweetview/index.html?sid=' + sid)
# If an account exists but no logins are remaining, then direct the user to ante up
# via a PayPal Express Checkout pay flow
else:
# Store the user_info so we can retrieve it in the next request
memcache.set(sid, user_info, time=60 * 10) # seconds
product = Product.getProduct()
template_values = {
'title':
'Payment Required',
'msg':
'Get unlimited access to Tweet Relevance for %s %s for a one-time charge of only $%s!'
% (product['quantity'], product['units'],
str(product['price'])),
'sid':
sid
}
path = os.path.join(os.path.dirname(__file__), '..',
'templates', 'checkout.html')
self.response.out.write(template.render(path, template_values))
# Serves up stashed data (which takes place in a prior request to /app). A ?refresh=true parameter could
# be built in to the /data request to charge the user for another request handle associated details if so
# desired. This /data implementation simply returns the most previously calculated data
elif mode == "data":
user_info = memcache.get(self.request.get("sid"))
self.response.headers.add_header('content-type',
'application/json',
charset='utf-8')
self.response.out.write(
json.dumps(user_info['relevant_tweets'], indent=2))
elif mode == "login":
return self.redirect(client.get_authorization_url())
else: # root URL context
template_values = {
'title': 'Tweet Relevance',
}
path = os.path.join(os.path.dirname(__file__), '..', 'templates',
'root.html')
self.response.out.write(template.render(path, template_values))
