def get(self, fb_uid):
# This post is got from the cache. That's ok, because all of the actual
# dynamic data (votes, comments) is retrieved from the datastore during
# choosie_post.to_json().
user = CacheController.get_user_by_fb_id(fb_uid)
self.response.out.write(json.dumps(self.profile_details_json(user)))
def get(self):
vote_for = int(self.request.get('which_photo'))
fb_uid = str(self.request.get('fb_uid'))
user = CacheController.get_user_by_fb_id(fb_uid)
if not user:
self.write_error("Can't add vote: User with fb_uid %s is not logged in." % fb_uid)
return
# Since the post is taken from the cache, it might not be the most updated version
# but that's ok, as it is only used as 'parent'
choosie_post = CacheController.get_model(self.request.get('post_key'))
vote = Vote(parent=choosie_post,
user_fb_id=fb_uid,
vote_for=int(vote_for))
prev_vote = vote.prev_vote_for_user_for_post()
#if the user voted to the same post but for different item, updating the vote
if (prev_vote is not None and prev_vote.vote_for != vote_for):
prev_vote.vote_for = vote_for
prev_vote.put()
choosie_post.add_vote_to_post(vote, False)
self.response.write('Vote changed to photo number %d.' % vote_for)
#if voted to same pic - error
elif(prev_vote != None):
self.write_error("already voted!")
else:
vote.put()
ChoosiePost.add_vote_to_post(choosie_post, vote, True)
# Make sure the ChoosiePost is invalidated in cache, so that next time it is asked
# for, the updated one is retreived.
Vote.invalidate_votes(self.request.get('post_key'))
self.response.write('A new vote issued for photo number %d.' % vote_for)
def get(self, fb_uid):
# This post is got from the cache. That's ok, because all of the actual
# dynamic data (votes, comments) is retrieved from the datastore during
# choosie_post.to_json().
user = CacheController.get_user_by_fb_id(fb_uid)
self.response.out.write(json.dumps(self.profile_details_json(user)))
def build_comment_model_from_fb_comment(json_comment):
comment = Comment(user_fb_id=json_comment["from"]["id"],
created_at=Utils.parse_utf_format_datetime(json_comment["created_time"]),
text=json_comment["message"])
choosie_user = CacheController.get_user_by_fb_id(json_comment["from"]["id"])
if choosie_user is None:
comment.is_scraped = True
comment.scraped_user_details = str(ScrapeCommentsHandler.build_user_details(json_comment))
return comment
def build_comment_model_from_fb_comment(json_comment):
comment = Comment(user_fb_id=json_comment["from"]["id"],
created_at=Utils.parse_utf_format_datetime(json_comment["created_time"]),
text=json_comment["message"])
choosie_user = CacheController.get_user_by_fb_id(json_comment["from"]["id"])
if choosie_user is None:
comment.is_scraped = True
comment.scraped_user_details = str(ScrapeCommentsHandler.build_user_details(json_comment))
return comment
def notify_comment_async(self, choosie_post_key, user_fb_uid, commenter_name):
try:
user = CacheController.get_user_by_fb_id(user_fb_uid)
result = NotifyHandler.send_notifiction(NotifyHandler.notify_type["comment"],
commenter_name,
str(choosie_post_key),
[user])
logging.info("result of notifying on comment from " + commenter_name + " : " + result)
except Exception, e:
logging.error("Faled to notify on new comment: %s" % e)
def notify_vote_async(self, choosie_post_key, user_fb_uid, name_of_from_user):
try:
user = CacheController.get_user_by_fb_id(user_fb_uid)
result = NotifyHandler.send_notifiction(NotifyHandler.notify_type["vote"],
name_of_from_user,
str(choosie_post_key),
[user])
logging.info("result of notifying on vote from " + name_of_from_user + " : " + result)
except Exception, e:
logging.error("Faled to notify on new vote: %s" % e)
def from_string_for_choosie_post(comment_str):
# When parsing the string represantation (see to_string_for_choosie_post() above),
# there are two options.
as_dict = ast.literal_eval(comment_str)
if "user_fb_id" in as_dict:
# For option 1 (regualr, not scraped comments), we need to also get the user
# details.
user = CacheController.get_user_by_fb_id(as_dict["user_fb_id"])
del as_dict["user_fb_id"]
as_dict["user"] = user.to_short_json()
return as_dict
def from_string_for_choosie_post(comment_str):
# When parsing the string represantation (see to_string_for_choosie_post() above),
# there are two options.
as_dict = ast.literal_eval(comment_str)
if "user_fb_id" in as_dict:
# For option 1 (regualr, not scraped comments), we need to also get the user
# details.
user = CacheController.get_user_by_fb_id(as_dict["user_fb_id"])
del as_dict["user_fb_id"]
as_dict["user"] = user.to_short_json()
return as_dict
def post(self):
fb_uid = str(self.request.get('fb_uid'))
device_id = str(self.request.get('device_id'))
user = CacheController.get_user_by_fb_id(fb_uid)
if user is not None:
logging.info("device id was set to " + device_id)
user.device_id = device_id
user.put()
CacheController.invalidate_user_fb_id(fb_uid)
logging.info("Device was registered successfully for user " + user.first_name + " " + user.last_name)
else:
logging.error("No user was found with user_id %s. Failed to register device." % fb_uid)
def post(self, fb_uid):
user = CacheController.get_user_by_fb_id(fb_uid)
nick = self.request.get("nick")
info = self.request.get("info")
if nick == "":
user.nick = None
else:
user.nick = nick
user.info = info
user.put()
CacheController.invalidate_user_fb_id(fb_uid)
self.response.out.write(json.dumps({"success": "true"}))
def notify_vote_async(self, choosie_post_key, user_fb_uid,
name_of_from_user):
try:
user = CacheController.get_user_by_fb_id(user_fb_uid)
result = NotifyHandler.send_notifiction(
NotifyHandler.notify_type["vote"], name_of_from_user,
str(choosie_post_key), [user])
logging.info("result of notifying on vote from " +
name_of_from_user + " : " + result)
except Exception, e:
logging.error("Faled to notify on new vote: %s" % e)
def notify_comment_async(self, choosie_post_key, user_fb_uid,
commenter_name):
try:
user = CacheController.get_user_by_fb_id(user_fb_uid)
result = NotifyHandler.send_notifiction(
NotifyHandler.notify_type["comment"], commenter_name,
str(choosie_post_key), [user])
logging.info("result of notifying on comment from " +
commenter_name + " : " + result)
except Exception, e:
logging.error("Faled to notify on new comment: %s" % e)
def post(self, fb_uid):
user = CacheController.get_user_by_fb_id(fb_uid)
nick = self.request.get("nick")
info = self.request.get("info")
if nick == "":
user.nick = None
else:
user.nick = nick
user.info = info
user.put()
CacheController.invalidate_user_fb_id(fb_uid)
self.response.out.write(json.dumps({"success" : "true"}))
def post(self):
fb_access_token = str(self.request.get("fb_access_token"))
fb_uid = str(self.request.get("fb_uid"))
fb_access_token_expdate = Utils.get_access_token_from_request(self.request)
user = CacheController.get_user_by_fb_id(fb_uid)
if user is None:
User.create(fb_access_token, fb_access_token_expdate)
self.response.write("User created.")
else:
# updating access token fields
user.fb_access_token = fb_access_token
user.fb_access_token_expdate = fb_access_token_expdate
user.put()
self.response.write("User [%s %s] logged in successfully." % (user.first_name, user.last_name))
def from_string_for_choosie_post(vote_str, keep_shallow=False):
as_dict = ast.literal_eval(vote_str)
if "user_fb_id" in as_dict:
# For option 1 (regular, not scraped comments), we need to also get the user
# details.
if keep_shallow:
user = {"fb_uid": as_dict["user_fb_id"]}
else:
user = CacheController.get_user_by_fb_id(as_dict["user_fb_id"]).to_short_json()
del as_dict["user_fb_id"]
as_dict["user"] = user
return as_dict
def post(self):
fb_uid = str(self.request.get('fb_uid'))
device_id = str(self.request.get('device_id'))
user = CacheController.get_user_by_fb_id(fb_uid)
if user is not None:
logging.info("device id was set to " + device_id)
user.device_id = device_id
user.put()
CacheController.invalidate_user_fb_id(fb_uid)
logging.info("Device was registered successfully for user " +
user.first_name + " " + user.last_name)
else:
logging.error(
"No user was found with user_id %s. Failed to register device."
% fb_uid)
def from_string_for_choosie_post(vote_str, keep_shallow=False):
as_dict = ast.literal_eval(vote_str)
if "user_fb_id" in as_dict:
# For option 1 (regular, not scraped comments), we need to also get the user
# details.
if keep_shallow:
user = {"fb_uid": as_dict["user_fb_id"]}
else:
user = CacheController.get_user_by_fb_id(
as_dict["user_fb_id"]).to_short_json()
del as_dict["user_fb_id"]
as_dict["user"] = user
return as_dict
def post(self):
fb_access_token = str(self.request.get('fb_access_token'))
fb_uid = str(self.request.get('fb_uid'))
fb_access_token_expdate = Utils.get_access_token_from_request(
self.request)
user = CacheController.get_user_by_fb_id(fb_uid)
if user is None:
User.create(fb_access_token, fb_access_token_expdate)
self.response.write('User created.')
else:
# updating access token fields
user.fb_access_token = fb_access_token
user.fb_access_token_expdate = fb_access_token_expdate
user.put()
self.response.write('User [%s %s] logged in successfully.' %
(user.first_name, user.last_name))
def add_vote_to_post(self, vote, is_new):
db.run_in_transaction(ChoosiePost.add_vote_to_post_transaction, self.key(), vote)
logging.info("user_id" + self.user_fb_id)
logging.info("vote_id " + vote.user_fb_id)
if is_new:
user = CacheController.get_user_by_fb_id(self.user_fb_id)
if user.num_votes:
user.num_votes += 1
else:
user.num_votes = 1
user.put()
CacheController.invalidate_user_fb_id(user.fb_uid)
if self.user_fb_id != vote.user_fb_id and self.created_at > datetime.datetime.now() - datetime.timedelta(0.1): # if i didnt vote on my self and the post was uploaded less then 2.5 hours ago
vote_from = vote.get_user().display_name()
deferred.defer(self.notify_vote_async, self.key(), self.user_fb_id, vote_from)
def post(self):
user = CacheController.get_user_by_fb_id(self.request.get('fb_uid'))
logging.info(self.request.get('fb_uid'))
if user is None:
self.error(500)
logging.error("user not found!")
return
logging.info("user found!")
logging.info("share_to_fb_param: " +
self.request.get("share_to_fb", default_value="off"))
if (self.request.get("share_to_fb", default_value="off") == "on"):
logging.info("user" + user.fb_access_token)
logging.info("user_db" + str(self.request.get('fb_access_token')))
logging.info("key " + str(user.key()))
# updating user access token cause he might added publish_stream permission
if (user.fb_access_token != str(
self.request.get('fb_access_token'))):
logging.info("Changing access_token!")
user.fb_access_token = str(self.request.get('fb_access_token'))
user.fb_access_token_expdate = Utils.get_access_token_from_request(
self.request)
user.put()
CacheController.invalidate_user_fb_id(user.fb_uid)
photo1_blob_key = Utils.write_file_to_blobstore(
self.shrinkImage(self.request.get('photo1')))
photo2_blob_key = Utils.write_file_to_blobstore(
self.shrinkImage(self.request.get('photo2')))
choosie_post = ChoosiePost(question=self.request.get('question'),
user_fb_id=self.request.get('fb_uid'),
photo1_blob_key=photo1_blob_key,
photo2_blob_key=photo2_blob_key)
# Save this post in the datastore, and also in the memcache.
choosie_post.put()
CacheController.set_model(choosie_post)
logging.info("share:" +
self.request.get("share_to_fb", default_value="off"))
if (self.request.get("share_to_fb") == "on"):
logging.info("publishing!!")
choosie_post.publish_to_facebook(self.request.host_url)
self.redirect('/')
def post(self):
user = CacheController.get_user_by_fb_id(self.request.get('fb_uid'))
logging.info(self.request.get('fb_uid'))
if user is None:
self.error(500)
logging.error("user not found!")
return
logging.info("user found!")
logging.info("share_to_fb_param: " + self.request.get("share_to_fb", default_value="off"))
if (self.request.get("share_to_fb", default_value="off") == "on"):
logging.info("user" + user.fb_access_token)
logging.info("user_db" + str(self.request.get('fb_access_token')))
logging.info("key " + str(user.key()))
# updating user access token cause he might added publish_stream permission
if (user.fb_access_token != str(self.request.get('fb_access_token'))):
logging.info("Changing access_token!")
user.fb_access_token = str(self.request.get('fb_access_token'))
user.fb_access_token_expdate = Utils.get_access_token_from_request(self.request)
user.put()
CacheController.invalidate_user_fb_id(user.fb_uid)
photo1_blob_key = Utils.write_file_to_blobstore(self.shrinkImage(self.request.get('photo1')))
photo2_blob_key = Utils.write_file_to_blobstore(self.shrinkImage(self.request.get('photo2')))
choosie_post = ChoosiePost(question = self.request.get('question'),
user_fb_id = self.request.get('fb_uid'),
photo1_blob_key = photo1_blob_key,
photo2_blob_key = photo2_blob_key)
# Save this post in the datastore, and also in the memcache.
choosie_post.put()
CacheController.set_model(choosie_post)
logging.info("share:" + self.request.get("share_to_fb", default_value="off"))
if (self.request.get("share_to_fb") == "on"):
logging.info("publishing!!")
choosie_post.publish_to_facebook(self.request.host_url)
self.redirect('/')
def add_vote_to_post(self, vote, is_new):
db.run_in_transaction(ChoosiePost.add_vote_to_post_transaction,
self.key(), vote)
logging.info("user_id" + self.user_fb_id)
logging.info("vote_id " + vote.user_fb_id)
if is_new:
user = CacheController.get_user_by_fb_id(self.user_fb_id)
if user.num_votes:
user.num_votes += 1
else:
user.num_votes = 1
user.put()
CacheController.invalidate_user_fb_id(user.fb_uid)
if self.user_fb_id != vote.user_fb_id and self.created_at > datetime.datetime.now(
) - datetime.timedelta(
0.1
): # if i didnt vote on my self and the post was uploaded less then 2.5 hours ago
vote_from = vote.get_user().display_name()
deferred.defer(self.notify_vote_async, self.key(), self.user_fb_id,
vote_from)
def post(self):
fb_uid = str(self.request.get('fb_uid'))
# TODO: Make sure text is Unicode
text = self.request.get('text')
# Since the post is taken from the cache, it might not be the most updated version
# but that's ok, as it is only used as 'parent'
choosie_post = CacheController.get_model(self.request.get('post_key'))
fb_uid = self.request.get('fb_uid')
user = CacheController.get_user_by_fb_id(fb_uid)
if not user:
self.response.write(
"Comment not added: User with fb_uid %s is not logged in." %
fb_uid)
return
comment = Comment(parent=choosie_post, user_fb_id=fb_uid, text=text)
comment.put()
choosie_post.add_comment_to_post(comment)
# Make sure the ChoosiePost's comments are invalidated in cache, so that next time
# they are asked for, the updated are retreived.
Comment.invalidate_comments(self.request.get('post_key'))
self.response.write('Comment added.')
def post(self):
fb_uid = str(self.request.get('fb_uid'))
# TODO: Make sure text is Unicode
text = self.request.get('text')
# Since the post is taken from the cache, it might not be the most updated version
# but that's ok, as it is only used as 'parent'
choosie_post = CacheController.get_model(self.request.get('post_key'))
fb_uid = self.request.get('fb_uid')
user = CacheController.get_user_by_fb_id(fb_uid)
if not user:
self.response.write("Comment not added: User with fb_uid %s is not logged in." % fb_uid)
return
comment = Comment(parent=choosie_post,
user_fb_id=fb_uid,
text=text)
comment.put()
choosie_post.add_comment_to_post(comment)
# Make sure the ChoosiePost's comments are invalidated in cache, so that next time
# they are asked for, the updated are retreived.
Comment.invalidate_comments(self.request.get('post_key'))
self.response.write('Comment added.')
def post(self):
user = CacheController.get_user_by_fb_id(self.request.get('fb_uid'))
logging.info(self.request.get('fb_uid'))
if user is None:
self.error(500)
logging.error("user not found!")
return
logging.info("user found!")
logging.info("share_to_fb_param: " + self.request.get("share_to_fb", default_value="off"))
debug_show_fb = self.request.get("debug_show_fb", default_value="")
logging.info("debug_show_fb: " + debug_show_fb)
post_type_id = int(self.request.get("post_type_id", default_value="1"))
if debug_show_fb:
img1 = images.Image(self.shrinkImage(self.request.get('photo1')))
img2 = images.Image(self.shrinkImage(self.request.get('photo2')))
self.response.headers['Content-Type'] = 'image/png'
self.response.out.write(Utils.compose_two_images(img1, img2))
return
if self.request.get("share_to_fb", default_value="off") == "on":
logging.info("user" + user.fb_access_token)
logging.info("user_db" + str(self.request.get('fb_access_token')))
logging.info("key " + str(user.key()))
# updating user access token cause he might added publish_stream permission
if user.fb_access_token != str(self.request.get('fb_access_token')):
logging.info("Changing access_token!")
user.fb_access_token = str(self.request.get('fb_access_token'))
user.fb_access_token_expdate = Utils.get_access_token_from_request(self.request)
user.put()
CacheController.invalidate_user_fb_id(user.fb_uid)
if user.num_votes:
user.num_votes += 1
else:
user.num_votes = 1
user.put()
CacheController.invalidate_user_fb_id(user.fb_uid)
photo1_blob_key = Utils.write_file_to_blobstore(self.shrinkImage(self.request.get('photo1')))
if post_type_id == 1:
photo2_blob_key = Utils.write_file_to_blobstore(self.shrinkImage(self.request.get('photo2')))
else:
photo2_blob_key = None
choosie_post = ChoosiePost(question = self.request.get('question'),
user_fb_id = self.request.get('fb_uid'),
photo1_blob_key = photo1_blob_key,
photo2_blob_key = photo2_blob_key,
post_type_id = post_type_id)
# Save this post in the datastore, and also in the memcache.
choosie_post.put()
CacheController.set_model(choosie_post)
logging.info("share:" + self.request.get("share_to_fb", default_value="off"))
if self.request.get("share_to_fb") == "on":
logging.info("publishing!!")
choosie_post.publish_to_facebook(self.request.host_url)
choosie_post.notify_friends()
self.redirect('/')
def get_user(self): return CacheController.get_user_by_fb_id(self.user_fb_id)
def post(self):
user = CacheController.get_user_by_fb_id(self.request.get('fb_uid'))
logging.info(self.request.get('fb_uid'))
if user is None:
self.error(500)
logging.error("user not found!")
return
logging.info("user found!")
logging.info("share_to_fb_param: " +
self.request.get("share_to_fb", default_value="off"))
debug_show_fb = self.request.get("debug_show_fb", default_value="")
logging.info("debug_show_fb: " + debug_show_fb)
post_type_id = int(self.request.get("post_type_id", default_value="1"))
if debug_show_fb:
img1 = images.Image(self.shrinkImage(self.request.get('photo1')))
img2 = images.Image(self.shrinkImage(self.request.get('photo2')))
self.response.headers['Content-Type'] = 'image/png'
self.response.out.write(Utils.compose_two_images(img1, img2))
return
if self.request.get("share_to_fb", default_value="off") == "on":
logging.info("user" + user.fb_access_token)
logging.info("user_db" + str(self.request.get('fb_access_token')))
logging.info("key " + str(user.key()))
# updating user access token cause he might added publish_stream permission
if user.fb_access_token != str(
self.request.get('fb_access_token')):
logging.info("Changing access_token!")
user.fb_access_token = str(self.request.get('fb_access_token'))
user.fb_access_token_expdate = Utils.get_access_token_from_request(
self.request)
user.put()
CacheController.invalidate_user_fb_id(user.fb_uid)
if user.num_votes:
user.num_votes += 1
else:
user.num_votes = 1
user.put()
CacheController.invalidate_user_fb_id(user.fb_uid)
photo1_blob_key = Utils.write_file_to_blobstore(
self.shrinkImage(self.request.get('photo1')))
if post_type_id == 1:
photo2_blob_key = Utils.write_file_to_blobstore(
self.shrinkImage(self.request.get('photo2')))
else:
photo2_blob_key = None
choosie_post = ChoosiePost(question=self.request.get('question'),
user_fb_id=self.request.get('fb_uid'),
photo1_blob_key=photo1_blob_key,
photo2_blob_key=photo2_blob_key,
post_type_id=post_type_id)
# Save this post in the datastore, and also in the memcache.
choosie_post.put()
CacheController.set_model(choosie_post)
logging.info("share:" +
self.request.get("share_to_fb", default_value="off"))
if self.request.get("share_to_fb") == "on":
logging.info("publishing!!")
choosie_post.publish_to_facebook(self.request.host_url)
choosie_post.notify_friends()
self.redirect('/')
