def prefetch_posts_list(posts):
prefetch_refprops(posts, Post.user)
posts_keys = [str(post.key()) for post in posts]
# get user, if no user, all already_voted = no
session = get_current_session()
if session.has_key('user'):
user = session['user']
memcache_voted_keys = [
"vp_" + post_key + "_" + str(user.key()) for post_key in posts_keys
]
memcache_voted = memcache.get_multi(memcache_voted_keys)
memcache_to_add = {}
for post in posts:
vote_value = memcache_voted.get("vp_" + str(post.key()) + "_" +
str(user.key()))
if vote_value is not None:
post.prefetched_already_voted = vote_value == 1
else:
vote = Vote.all().filter("user ="******"post =", post).fetch(1)
memcache_to_add["vp_" + str(post.key()) + "_" +
str(user.key())] = len(vote)
post.prefetched_already_voted = len(vote) == 1
if memcache_to_add.keys():
memcache.add_multi(memcache_to_add, 3600)
else:
for post in posts:
post.prefetched_already_voted = False
# now the sum_votes
memcache_sum_votes_keys = ["p_" + post_key for post_key in posts_keys]
memcache_sum_votes = memcache.get_multi(memcache_sum_votes_keys)
memcache_to_add = {}
for post in posts:
sum_votes_value = memcache_sum_votes.get("p_" + str(post.key()))
if sum_votes_value is not None:
post.prefetched_sum_votes = sum_votes_value
else:
sum_votes = Vote.all().filter("post =", post).count()
memcache_to_add["p_" + str(post.key())] = sum_votes
post.prefetched_sum_votes = sum_votes
if memcache_to_add.keys():
memcache.add_multi(memcache_to_add, 3600)
# finally we get all the comment count from memcache
memcache_comment_count_keys = ["pc_" + post_key for post_key in posts_keys]
memcache_comment_count = memcache.get_multi(memcache_comment_count_keys)
memcache_to_add = {}
for post in posts:
comment_count = memcache_comment_count.get("pc_" + str(post.key()))
if comment_count is not None:
post.cached_comment_count = comment_count
else:
comment_count = post.comments.count()
memcache_to_add["pc_" + str(post.key())] = comment_count
post.cached_comment_count = comment_count
if memcache_to_add.keys():
memcache.add_multi(memcache_to_add, 3600)
def prefetch_posts_list(posts):
prefetch_refprops(posts, Post.user)
posts_keys = [str(post.key()) for post in posts]
# get user, if no user, all already_voted = no
session = get_current_session()
if session.has_key('user'):
user = session['user']
memcache_voted_keys = ["vp_" + post_key + "_" + str(user.key()) for post_key in posts_keys]
memcache_voted = memcache.get_multi(memcache_voted_keys)
memcache_to_add = {}
for post in posts:
vote_value = memcache_voted.get("vp_" + str(post.key()) + "_" +str(user.key()))
if vote_value is not None:
post.prefetched_already_voted = vote_value == 1
else:
vote = Vote.all().filter("user ="******"post =", post).fetch(1)
memcache_to_add["vp_" + str(post.key()) + "_" + str(user.key())] = len(vote)
post.prefetched_already_voted = len(vote) == 1
if memcache_to_add.keys():
memcache.add_multi(memcache_to_add, 3600)
else:
for post in posts:
post.prefetched_already_voted = False
# now the sum_votes
memcache_sum_votes_keys = ["p_" + post_key for post_key in posts_keys]
memcache_sum_votes = memcache.get_multi(memcache_sum_votes_keys)
memcache_to_add = {}
for post in posts:
sum_votes_value = memcache_sum_votes.get("p_" + str(post.key()))
if sum_votes_value is not None:
post.prefetched_sum_votes = sum_votes_value
else:
sum_votes = Vote.all().filter("post =", post).count()
memcache_to_add["p_" + str(post.key())] = sum_votes
post.prefetched_sum_votes = sum_votes
if memcache_to_add.keys():
memcache.add_multi(memcache_to_add, 3600)
# finally we get all the comment count from memcache
memcache_comment_count_keys = ["pc_" + post_key for post_key in posts_keys]
memcache_comment_count = memcache.get_multi(memcache_comment_count_keys)
memcache_to_add = {}
for post in posts:
comment_count = memcache_comment_count.get("pc_" + str(post.key()))
if comment_count is not None:
post.cached_comment_count = comment_count
else:
comment_count = post.comments.count()
memcache_to_add["pc_" + str(post.key())] = comment_count
post.cached_comment_count = comment_count
if memcache_to_add.keys():
memcache.add_multi(memcache_to_add, 3600)
def prefetch_comment_list(comments):
prefetch_refprops(comments, Comment.user, Comment.post)
# call all the memcache information
# starting by the already_voted area
comment_keys = [str(comment.key()) for comment in comments]
session = get_current_session()
if session.has_key('user'):
user = session['user']
memcache_voted_keys = [
"cp_" + comment_key + "_" + str(user.key())
for comment_key in comment_keys
]
memcache_voted = memcache.get_multi(memcache_voted_keys)
memcache_to_add = {}
for comment in comments:
vote_value = memcache_voted.get("cp_" + str(comment.key()) + "_" +
str(user.key()))
if vote_value is not None:
comment.prefetched_already_voted = vote_value == 1
else:
vote = Vote.all().filter("user ="******"comment =",
comment).fetch(1)
memcache_to_add["cp_" + str(comment.key()) + "_" +
str(user.key())] = len(vote)
comment.prefetched_already_voted = len(vote) == 1
if memcache_to_add.keys():
memcache.add_multi(memcache_to_add, 3600)
else:
for comment in comments:
comment.prefetched_already_voted = False
# now the sum_votes
memcache_sum_votes_keys = [
"c_" + comment_key for comment_key in comment_keys
]
memcache_sum_votes = memcache.get_multi(memcache_sum_votes_keys)
memcache_to_add = {}
for comment in comments:
sum_votes_value = memcache_sum_votes.get("c_" + str(comment.key()))
if sum_votes_value is not None:
comment.prefetched_sum_votes = sum_votes_value
else:
sum_votes = Vote.all().filter("comment =", comment).count()
memcache_to_add["c_" + str(comment.key())] = sum_votes
comment.prefetched_sum_votes = sum_votes
if memcache_to_add.keys():
memcache.add_multi(memcache_to_add, 3600)
def vote(request, id):
"""
Add a vote for a feedback message, but not twice from the same IP.
"""
referer = request.META.get('HTTP_REFERER', '/feedback/')
redirect = HttpResponseRedirect(referer)
# Check if the selected feedback exists.
feedback = Feedback.get_by_id(int(id))
if feedback is None:
logging.info("Feedback '%s' not found." % id)
return redirect
# Check if this feedback was posted from the same IP.
ip = request.META.get('REMOTE_ADDR', '0.0.0.0')
if feedback.ip == ip:
logging.info("Feedback '%s' was posted from the same IP." % id)
return redirect
# Check if this IP has already voted for this feedback.
already = Vote.all().filter('feedback', feedback).filter('ip', ip).count()
if already:
logging.info("Feedback '%s' was already voted %d times from this IP."
% (id, already))
return redirect
# Register this vote to prevent double voting.
vote = Vote(feedback=feedback, ip=ip)
vote.put()
# Increase the points for this feedback.
feedback.points += 1
feedback.put()
return redirect
def vote(request, id):
"""
Add a vote for a feedback message, but not twice from the same IP.
"""
referer = request.META.get('HTTP_REFERER', '/feedback/')
redirect = HttpResponseRedirect(referer)
# Check if the selected feedback exists.
feedback = Feedback.get_by_id(int(id))
if feedback is None:
logging.debug("Feedback '%s' not found." % id)
return redirect
# Check if this feedback was posted from the same IP.
ip = request.META.get('REMOTE_ADDR', '0.0.0.0')
if feedback.ip == ip:
logging.debug("Feedback '%s' was posted from the same IP." % id)
return redirect
# Check if this IP has already voted for this feedback.
already = Vote.all().filter('feedback', feedback).filter('ip', ip).count()
if already:
logging.debug("Feedback '%s' was already voted %d times from this IP."
% (id, already))
return redirect
# Register this vote to prevent double voting.
vote = Vote(feedback=feedback, ip=ip)
vote.put()
# Increase the points for this feedback.
feedback.points += 1
feedback.put()
return redirect
def get_already_voted(request):
"""
Don't show vote buttons if posted or voted from the same IP.
"""
ip = request.META.get('REMOTE_ADDR', '0.0.0.0')
posted = [feedback.id()
for feedback in Feedback.all(keys_only=True).filter('ip', ip)]
voted = [vote.feedback_id()
for vote in Vote.all().filter('ip', ip)]
# logging.debug('posted=%s voted=%s' % (posted, voted))
return set(posted + voted)
def get_already_voted(request):
"""
Don't show vote buttons if posted or voted from the same IP.
"""
ip = request.META.get('REMOTE_ADDR', '0.0.0.0')
posted = [feedback.id()
for feedback in Feedback.all(keys_only=True).filter('ip', ip)]
voted = [vote.feedback_id()
for vote in Vote.all().filter('ip', ip)]
# logging.debug('posted=%s voted=%s' % (posted, voted))
return set(posted + voted)
def prefetch_comment_list(comments):
prefetch_refprops(comments, Comment.user, Comment.post)
# call all the memcache information
# starting by the already_voted area
comment_keys = [str(comment.key()) for comment in comments]
session = get_current_session()
if session.has_key('user'):
user = session['user']
memcache_voted_keys = ["cp_" + comment_key + "_" + str(user.key()) for comment_key in comment_keys]
memcache_voted = memcache.get_multi(memcache_voted_keys)
memcache_to_add = {}
for comment in comments:
vote_value = memcache_voted.get("cp_" + str(comment.key()) + "_" +str(user.key()))
if vote_value is not None:
comment.prefetched_already_voted = vote_value == 1
else:
vote = Vote.all().filter("user ="******"comment =", comment).fetch(1)
memcache_to_add["cp_" + str(comment.key()) + "_" + str(user.key())] = len(vote)
comment.prefetched_already_voted = len(vote) == 1
if memcache_to_add.keys():
memcache.add_multi(memcache_to_add, 3600)
else:
for comment in comments:
comment.prefetched_already_voted = False
# now the sum_votes
memcache_sum_votes_keys = ["c_" + comment_key for comment_key in comment_keys]
memcache_sum_votes = memcache.get_multi(memcache_sum_votes_keys)
memcache_to_add = {}
for comment in comments:
sum_votes_value = memcache_sum_votes.get("c_" + str(comment.key()))
if sum_votes_value is not None:
comment.prefetched_sum_votes = sum_votes_value
else:
sum_votes = Vote.all().filter("comment =", comment).count()
memcache_to_add["c_" + str(comment.key())] = sum_votes
comment.prefetched_sum_votes =sum_votes
if memcache_to_add.keys():
memcache.add_multi(memcache_to_add, 3600)
def post(self):
method = self.request.get("method", None)
number = self.request.get("number", None)
cursor = self.request.get("cursor", None)
refresh = self.request.get("refresh", None)
random_text = self.request.get("random_text", "")
try:
number = int(number)
except:
number = None
if random_text == "random":
showed_random = True
else:
showed_random = False
if method and number and method in OPTIONS:
key_name = "%s-%s-%s" % (method, number, showed_random)
stat = VoteStat.get_or_insert(key_name)
q = Vote.all()
q.filter("method =", method)
q.filter("number =", number)
q.filter("showed_random =", showed_random)
if cursor:
q.with_cursor(cursor)
count = q.count()
next_cursor = q.cursor() if count == 1000 else None
if refresh or not stat.count:
stat.count = 0
stat.count = stat.count + count
stat.method = method
stat.number = number
stat.showed_random = showed_random
stat.generated = datetime.now()
stat.put()
if next_cursor:
params = {"number": number, "method": method, "cursor": next_cursor, "random_text": random_text}
taskqueue.add(url="/tasks/tally-votes", params=params)
def vote(netid, talk_id, direction):
app.logger.info(dir(netid))
app.logger.info(netid)
votes = Vote.all()
votes.filter('talk_id =', talk_id)
votes.filter('netid =', netid)
votes_res = votes.fetch(1)
netid = str(netid)
if len(votes.fetch(1)) < 1 or (votes_res[0].direction != 'up' and votes_res[0].direction != 'down'):
# User has not voted before
new_vote = Vote(direction=direction, netid=str(netid), talk_id=talk_id)
talk = Talk.get_by_id(talk_id)
if direction == 'up':
talk.votes += 1
elif direction == 'down':
talk.votes -= 1
talk.put()
new_vote.put()
app.logger.info("Did a vote")
return redirect(url_for('index'))
elif votes_res[0].direction != direction:
# The user has voted and is changing
vote = votes_res[0]
vote.direction = direction
talk = Talk.get_by_id(talk_id)
if direction == 'up':
talk.votes += 2
elif direction == 'down':
talk.votes -= 2
talk.put()
vote.put()
app.logger.info("Did a exist vote")
return redirect(url_for('index'))
else:
# User is not allowed to vote
return redirect(url_for('index'))
def index(netid):
talks = Talk.all()
all_votes = Vote.all()
votes = all_votes.filter('netid =', netid)
return render_template('index.html', talks=talks, votes=votes, ticket=request.args['ticket'], netid=netid)
def get(self):
skeleton_key = self.request.get("skeleton", None)
if settings.THROTTLE_API and skeleton_key != settings.SKELETON_KEY:
ip = str(self.request.remote_addr)
throttle = memcache.get(ip)
if throttle:
throttle = throttle - datetime.now()
jsonResponse(self, {
'status': 'throttled',
'remaining': throttle.seconds
})
return
else:
throttle = datetime.now() + timedelta(
seconds=settings.THROTTLE_LIFE)
memcache.set(ip, throttle, settings.THROTTLE_LIFE)
method = self.request.get("method", None)
number = self.request.get("number", None)
random_text = self.request.get("random_text", None)
cursor = self.request.get("cursor", None)
showed_random = None
if random_text:
if random_text == 'visible':
showed_random = True
elif random_text == 'hidden':
showed_random = False
else:
self.error(400)
return
q = Vote.all()
if method:
if method in OPTIONS:
q.filter("method =", method)
else:
self.error(400)
return
if number is not None:
try:
number = int(number)
except:
self.error(400)
return
else:
q.filter("number =", number)
if showed_random is not None:
q.filter("showed_random =", showed_random)
if cursor:
try:
q.with_cursor(cursor)
except:
self.error(400)
return
data = None
cached_data = None
LIMIT = 1000
key = "%s-%s-%s-%s-%s" % (settings.VERSION, method, number,
random_text, cursor)
if settings.CACHE:
cached_data = memcache.get(key)
if not cached_data:
data = q.fetch(LIMIT)
next_cursor = q.cursor() if len(data) == LIMIT else None
result = {
"objects": [
vote.toJSON(full=(skeleton_key is not None))
for vote in data
],
"next_cursor":
next_cursor
}
if settings.CACHE and not skeleton_key:
memcache.set(key, result, settings.CACHE_LIFE)
else:
result = cached_data
jsonResponse(self, result)
def get(self):
skeleton_key = self.request.get("skeleton", None)
if settings.THROTTLE_API and skeleton_key != settings.SKELETON_KEY:
ip = str(self.request.remote_addr)
throttle = memcache.get(ip)
if throttle:
throttle = throttle - datetime.now()
jsonResponse(self, {
'status': 'throttled',
'remaining': throttle.seconds
})
return
else:
throttle = datetime.now() + timedelta(seconds=settings.THROTTLE_LIFE)
memcache.set(ip, throttle, settings.THROTTLE_LIFE)
method = self.request.get("method", None)
number = self.request.get("number", None)
random_text = self.request.get("random_text", None)
cursor = self.request.get("cursor", None)
showed_random = None
if random_text:
if random_text == 'visible':
showed_random = True
elif random_text == 'hidden':
showed_random = False
else:
self.error(400)
return
q = Vote.all()
if method:
if method in OPTIONS:
q.filter("method =", method)
else:
self.error(400)
return
if number is not None:
try:
number = int(number)
except:
self.error(400)
return
else:
q.filter("number =", number)
if showed_random is not None:
q.filter("showed_random =", showed_random)
if cursor:
try:
q.with_cursor(cursor)
except:
self.error(400)
return
data = None
cached_data = None
LIMIT = 1000
key = "%s-%s-%s-%s-%s" % (settings.VERSION, method, number, random_text, cursor)
if settings.CACHE:
cached_data = memcache.get(key)
if not cached_data:
data = q.fetch(LIMIT)
next_cursor = q.cursor() if len(data) == LIMIT else None
result = {
"objects" : [vote.toJSON(full=(skeleton_key is not None)) for vote in data],
"next_cursor" : next_cursor
}
if settings.CACHE and not skeleton_key:
memcache.set(key, result, settings.CACHE_LIFE)
else:
result = cached_data
jsonResponse(self, result)
def downvote(username, tweet):
u = Vote.all().filter('parent =', tweet).get()
if not u and tweet.votes > 0:
Vote(parent=tweet, user=username, down=True)
tweet.upvotes -= 1
return tweet.upvotes
def upvote(username, tweet):
u = Vote.all().filter('parent =', tweet).get()
if not u:
Vote(parent=tweet, user=username)
tweet.upvotes += 1
return tweet.upvotes
