def BatchUpdateVotes(update_fn_name, cursor=None, num_updated=0, p1=None, p2=None):
logging_ext.logging_ext.info("BatchUpdateVotes %s %d"%(update_fn_name,num_updated))
query = Vote.query()
to_put = []
q, cursor, more = query.fetch_page(BATCH_SIZE, start_cursor=cursor)
for vote in q:
if update_fn_name == "rename_category":
batch_rename_category_votes(vote, p1, p2)
elif update_fn_name == "reset-votes-json":
batch_reset_vote_json(vote)
else:
continue
to_put.append(vote)
if to_put:
ndb.put_multi(to_put)
num_updated += len(to_put)
logging.debug(
'Put %d votes to Datastore for a total of %d',
len(to_put), num_updated)
deferred.defer(
BatchUpdateVotes,
update_fn_name=update_fn_name,
cursor=cursor,
num_updated=num_updated,
p1=p1,
p2=p2)
else:
logging_ext.logging_ext.info(
'BatchUpdateVotes complete with %d updates!'% num_updated)
def update_votes(item, request_handler, user_id):
"""
save the vote for an item
:param item: {Item}
:param request_handler: {BaseHandler} for the request
:param user_id: {int}
"""
try:
old_votes = Vote.query(Vote.voter == user_id, Vote.item == item.key)
for v in old_votes:
v.key.delete()
vote = Vote()
vote.item = item.key
vote.voter = user_id
vote.comment = unicode(request_handler.request.get('myComment'))
vote.meal_kind = int(request_handler.request.get('kind'))
vote.place_style= int(request_handler.request.get('style'))
vote.cuisine = Category.get_by_id(request_handler.request.get('cuisine')).key
vote_stars = int(request_handler.request.get("voteScore"))
vote.stars = vote_stars
if vote_stars == 0:
vote_untried= bool(request_handler.request.get("voteUntried"))
else:
vote_untried = False
vote.untried = vote_untried
vote.put()
ndb_models.mark_vote_as_updated(str(vote.key.id()), user_id)
logging.info ('update_votes for %s "%s"=%d'%
(item.place_name,vote.comment,vote.stars))
except Exception, ex:
logging_ext.error("newOrUpdateItem votes exception", exc_info=True)
raise
def get(self, id):
"""
votes for an item
:param id: int
:return: json dict
"""
res = {}
it = Item.get_by_id(int(id))
if it:
votes = Vote.query(Vote.item == it.key)
# TODO: .order("when") but there are missing values for when
cursor = self.request.get("cursor")
if cursor:
votes.with_cursor(start_cursor=cursor)
results = votes[0:20]
next_cursor = votes.cursor()
res["cursor"] = next_cursor
more = len(results) >= 20
html = self.render_template_to_string(
"item-votes-list.htt",
{"votes": results, "more": more})
res["votesList"] = html
res["more"] = more
json.dump(res, self.response.out)
else:
self.abort(501)
def post(self):
vote_key = ndb.Key(Vote, int(self.request.get('vote_key')))
item_key = ndb.Key(Item, int(self.request.get('item_key')))
vote = vote_key.get()
it = item_key.get()
if it:
try:
old_votes = Vote.query(Vote.voter == vote.voter,
Vote.item == item_key)
for v in old_votes:
if v.key.id() != vote_key:
v.key.delete()
vote.meal_kind = int(self.request.get('kind'))
vote.place_style = int(self.request.get('style'))
cuisine = self.request.get('cuisine')
if cuisine:
vote.cuisine = Category.get_by_id(cuisine)
if not vote.cuisine:
vote.cuisine = vote.item.category
vote.put()
it.set_json()
ndb_models.mark_vote_as_updated(vote.key.id(), vote.voter)
logging.info('UpdateAdminVote for %s, %s' %
(it.place_name, vote_key))
except Exception, ex:
logging.error("UpdateAdminVote votes exception", exc_info=True)
raise
# mark user as dirty
self.response.out.write('OK')
logging.debug("UpdateAdminVote OK")
return
def change_votes_to_4_dot(self):
n=0
votes = Vote.query()
for v in votes:
if v.untried:
v.vote = VoteValue.VOTE_UNTRIED
v.cuisine = v.item.category
v.put()
n += 1
memcache.flush_all()
self.response.out.write("\n%d "%n)
def remove_orphan_votes(self):
# remove orphan votes after an item is deleted
votes = Vote.query()
for v in votes:
try:
it = v.item.get().place_name
except ReferencePropertyResolveError:
v.key.delete()
self.response.out.write('Delete 1')
except Exception:
self.response.out.write("FAIL ")
memcache.flush_all()
def remove_brunch(self):
items = Item.query()
for it in items:
if it.category.title == 'Brunch':
v = it.votes
if v:
first = v.get()
it.category = first.cuisine
it.put()
self.response.out.write("Set %s to %s<br>"%(it.place_name, first.cuisine.title))
for v in Vote.query():
if v.cuisine.title == 'Brunch':
self.response.out.write("BRUNCH: %s for %s<br>"%(v.key(), v.item.place_name))
def get(self, id):
"""
Get the votes for a friend
:param id: string
:return: json
"""
friend_id = int(id)
votes = Vote.query(Vote.voter ==friend_id)
res = {
'id': friend_id,
'votes': [vote.json for vote in votes]
}
json.dump(res, self.response.out, default=json_serial)
return
def post(self):
try:
if not check_good_server_version(self.request):
self.response.out.write("BAD VERSION")
return
it = update_item_internal(self, self.user_id)
logging.info('newOrUpdateItem %s by %s'%(it.place_name, self.user_id))
ndb_models.mark_place_as_updated(str(it.key.id()),str(self.user_id))
vote = Vote.query(Vote.voter == self.user_id, Vote.item == it.key).get()
res = {'place':it.get_json(),
'vote': vote.to_json()}
json.dump(res, self.response.out)
except:
logging_ext.error('newOrUpdateItem', exc_info=True)
def delete_item(handler, id):
"""
deletes the votes for an item
:param handler: RequestHandler
:param id: int
:return:
"""
try:
item = Item.get_by_id(int(id))
if item:
my_votes = Vote.query(Vote.voter == handler.user_id, Vote.item == item.key)
for vote in my_votes:
logging.info("deleteItem: " + str(vote.key))
vote.key.delete()
handler.response.write('OK')
except Exception:
logging_ext.error("delete_item", exc_info=True)
handler.abort(500)
def serialize_user_details(user_id, places_ids, current_user, request, since=None):
""" give the list of votes & places_ids for a user
@param user_id: int: which user
@param places_ids: dict: list of places_ids indexed by key (BY VALUE)
@param current_user: int: current user - if same as user_id then
we exclude untried
@return:
"""
try:
logging.info("serialize_user_details 1")
# get it from the cache
user_id = int(user_id)
votes = Vote.query(Vote.voter == user_id)
user = User.get_by_id(user_id)
user_profile = user.profile()
if getProp(user_profile, 'last_write'):
last_write = user_profile.last_write
else:
last_write = None
result = {"votes": votes,
"id": user_id,
# todo is it first_name?
'name': user_profile.screen_name,
'last_write': last_write}
if votes:
logging.debug("serialize_user_details: %d votes"%len(votes))
for place_key in votes:
if not place_key in places_ids:
place_json = Item.id_to_json(place_key)
# if user_id == current_user:
# place_json['vote'] = votes[place_key]['vote']
if "category" in place_json:
places_ids[place_key] = place_json
for place_id in places_ids:
pl = ndb.Key(Item,place_id).get()
json_data = pl.get_json()
places_ids[place_id] = json_data
logging.debug('serialize_user_details: Added %d places_ids'%len(places_ids))
else:
logging.debug("serialize_user_details: No Votes")
return result
except Exception, e:
logging_ext.error("serialize_user_details Exception", exc_info=True)
def change_votes_to_votevalue(self):
n=0
votes = Vote.query()
for v in votes:
if v.vote == 1:
v.vote = VoteValue.VOTE_LIKED
elif v.vote == -1:
v.vote = VoteValue.VOTE_DISLIKED
elif v.untried:
v.vote = VoteValue.VOTE_UNTRIED
else:
v.vote = VoteValue.VOTE_NONE
v.cuisine = v.item.category
if v.cuisine.title in ["Burger","Cafe","Fast food","Deli","Fish and chips"]:
v.place_style = PlaceStyle.STYLE_QUICK
v.put()
n += 1
memcache.flush_all()
self.response.out.write("\n%d "%n)
def votes_to_5_star(self):
votes = Vote.query() #.filter("vote =",0)
for v in votes:
if v.vote == VoteValue.VOTE_UNTRIED:
v.untried = True
v.stars = 0
elif v.vote == VoteValue.VOTE_DISLIKED:
v.stars = 1
v.untried = False
elif v.vote == VoteValue.VOTE_LIKED:
if v.stars == 0:
v.stars = 5
v.untried = False
else:
self.response.out.write("ERROR on vote %s - %s vote is %s<BR>"%(
str(v.key()),
v.item.place_name,
str(v.vote))
)
v.put()
memcache.flush_all()
def post(self):
if is_administrator():
try:
logging.info("SyncToProd")
seed_user = None
for u in User.query():
if 'pegah' in u.auth_ids:
seed_user = u.key
break
if seed_user:
logging.info("SyncToProd seed user")
url = 'https://rayv-app.appspot.com/admin/put_place_api'
place_list = json.loads(self.request.params['list'])
for place in place_list:
it = Item.get_by_id(place)
logging.info("SyncToProd sending " + it.place_name)
form_fields = place.id_to_json()
vote = Vote.query(Vote.voter == seed_user,
Vote.item == it.key).get()
if vote:
form_fields['myComment'] = vote.comment
form_fields['voteScore'] = vote.vote
else:
form_fields['voteScore'] = VoteValue.VOTE_LIKED
form_fields['myComment'] = ""
form_data = urllib.urlencode(form_fields)
result = urlfetch.fetch(
url=url,
payload=form_data,
method=urlfetch.POST,
headers={
'Content-Type':
'application/x-www-form-urlencoded'
})
else:
self.response.out.write('No Seed User')
except Exception:
logging.error('admin.SyncToProd', exc_info=True)
logging.info("Sync Done to Prod")
self.response.out.write("OK")
def post(self):
it_id = int(self.request.get('item_id'))
it = Item.get_by_id(it_id)
voteScore = int(self.request.get("vote"))
voteUntried = bool(self.request.get("untried"))
my_votes = Vote.query(Vote.voter == self.user_id, Vote.item == it.key)
if my_votes.count() == 0:
# a new vote
new_vote = Vote()
new_vote.item = it
new_vote.voter = self.user_id
else:
# roll back the old vote
new_vote = my_votes.get()
oldVote, oldUntried = new_vote.stars, new_vote.untried
new_vote.stars = voteScore
new_vote.untried = voteUntried
new_vote.comment = self.request.get("comment")
new_vote.when = datetime.datetime.now()
new_vote.put()
it.save()
# refresh cache
self.response.out.write('OK')
def set_vote_time_to_now(self):
votes = Vote.query()
for v in votes:
v.when = datetime.now()
v.put()
def get(self):
migration_name = self.request.get("m")
if migration_name == '1':
self.set_votes_up_down()
self.response.out.write("1-items OK")
votes = Vote.query()
for v in votes:
dirty = False
try:
if v.vote == True:
v.vote = 1
dirty = True
except:
v.vote = 1
dirty = True
if dirty:
v.put()
self.response.out.write("1-votes OK")
return
elif migration_name == '2':
self.move_comment_to_vote()
self.response.out.write("2-vote comments OK")
elif migration_name == '3':
self.at_least_one_vote_per_item()
self.response.out.write("3-vote totals OK")
elif migration_name == '4':
self.one_vote_per_item()
self.response.out.write("4-latLng OK")
elif migration_name == '5':
self.votes_down_to_abs()
self.response.out.write("5-+ve votes OK")
elif migration_name == "6":
self.add_geohash()
self.response.out.write("6 - geohash added OK")
elif migration_name == "7":
self.recalc_votes_totals()
self.response.out.write("7 - votes re-totaled OK")
elif migration_name == "8":
self.add_google_img_if_missing()
self.response.out.write("8 - images got from google OK")
elif migration_name == "9":
self.add_phone_numbers()
self.response.out.write("9 - phone nos got from google OK")
elif migration_name == "10":
self.item_title_to_StringProperty()
self.response.out.write("10 - title becomes place_name StringProp OK")
elif migration_name == "11":
self.remote_urls_to_blobs()
self.response.out.write("11 - images got from google into db OK")
elif migration_name == "remove_orphan_votes":
self.remove_orphan_votes()
self.response.out.write(json.dumps({
'status':'OK',
'detail':'12 - votes clean'}))
elif migration_name == "13":
self.add_websites()
self.response.out.write("13 - websites got from google OK")
elif migration_name == "14":
self.add_edited()
self.response.out.write("14 - last edit times added")
elif migration_name == "add-blocked":
self.add_blocked_to_user()
self.response.out.write("User blocked - added")
elif migration_name == "reset-vote-times":
self.set_vote_time_to_now()
self.response.out.write("Vote Times Reset")
elif migration_name == "add-cuisines":
self.add_cuisines()
self.response.out.write("Vote Times Reset")
elif migration_name == "add-addresses":
self.add_addresses()
self.response.out.write("Addresses Added")
elif migration_name == "add-cuisine":
self.add_new_cuisine()
self.response.out.write("Cuisine added")
elif migration_name == "set-vote-value":
self.change_votes_to_votevalue()
self.response.out.write("Vote values added")
elif migration_name == "reset-items-json":
self.wipe_item_json()
self.response.out.write("Places reset")
elif migration_name == "change-votes-to-4-dot":
self.change_votes_to_4_dot()
self.response.out.write("Places reset")
elif migration_name == "add_google_data":
self.add_google_data_if_missing()
self.response.out.write("Google data added")
elif migration_name == "dedup_votes":
self.only_one_vote_per_user_per_item()
self.response.out.write("Votes Deduplicated")
elif migration_name == "remove_brunch":
self.remove_brunch()
self.response.out.write("Brunch removed")
elif migration_name == "five_star":
self.votes_to_5_star()
self.response.out.write("Stars set")
elif migration_name == "reset-votes-json":
self.wipe_votes_json()
self.response.out.write("Json Wiped")
elif migration_name == "rename-category":
self.rename_category()
self.response.out.write("Cat renamed")
elif migration_name == "single-change-queue-places":
self.single_change_queue_places()
self.response.out.write("Queues merged")
elif migration_name == "single-change-queue-votes":
self.single_change_queue_votes()
self.response.out.write("Queues merged")
else:
logging_ext.logging_ext.error("No Migration - %s"%migration_name)
self.response.out.write("No Migration - %s"%migration_name)
def _clean_db():
ndb.delete_multi(GameNight.query().fetch(keys_only=True))
ndb.delete_multi(Vote.query().fetch(keys_only=True))
def get(self):
""" get the user record, including friends' places """
try:
if self.user.blocked:
raise Exception('Blocked')
my_id = self.user_id
except:
logging_ext.error('getFullUserRecord: User Exception')
json.dump({'result':'FAIL'},
self.response.out,
default=json_serial)
return
if my_id:
user = User.get_by_id(my_id)
if user:
# logged in
result = {
"id": my_id,
"admin": self.user.profile().is_admin }
since = None
if 'since' in self.request.params:
# move since back in time to allow for error
since = datetime.datetime.strptime(
self.request.params['since'],
config['DATETIME_FORMAT']) - \
config['TIMING_DELTA']
user_list = []
user_results = []
# is it for a specific user?
if "forUser" in self.request.params:
user_list.append(user.get(self.request.params['forUser']))
else:
if config['all_are_friends']:
q = User.gql('')
for user in q:
user_list.append(user)
places = {}
my_votes = Vote.query(Vote.voter==my_id)
for u in user_list:
user_id = u.get_id()
if user_id == my_id:
votes = my_votes
else:
votes = Vote.query(Vote.voter==u.get_id())
for v in votes:
#add to the list if it's not there, or overwrite if this is my version
if not v in places or user_id == my_id:
places [v] = Item.id_to_json(v)
user_profile = u.profile()
if getProp(user_profile, 'last_write'):
last_write = user_profile.last_write
else:
last_write = None
user_str = {"votes": votes,
"id": u.get_id(),
# todo is it first_name?
'name': u.screen_name,
'last_write': last_write}
user_results.append(user_str)
result["places"] = places
result["friendsData"] = user_results
json_str = json.dumps(
result,
default=json_serial)
self.response.out.write(json_str)
#profile_out("getFullUserRecord")
return
self.error(401)
