def get(self, id): """ get an Item :param id: int :return: string json """ try: it = Item.get_by_id(int(id)) res = {"place_name": it.place_name, "address": it.address, "cuisineName": it.category.title, "lat": str(it.lat), "lng": str(it.lng), "id": it.key.id() } if it.photo: res["img"] = it.key.id() if it.owner == self.user_id: res["mine"] = True res["descr"], res["stars"], res["untried"] = it.vote_from(it.owner) else: res["mine"] = False res["descr"], res["stars"], res["untried"] = it.vote_from(self.user_id) json.dump(res, self.response.out) except Exception: logging_ext.error("getItem_ajax Exception", exc_info=True) self.error(500)
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 post(self): # should run at most 1/s due to entity group limit """ Task Worker to mark place as updated Params: placeId: string place Id userId: string """ try: logging_ext.log_to_console("AddPlaceChangesWorker") place_id_str = self.request.get('placeId') user_id_str = self.request.get('userId') place_entries = Change.\ query(Change.kind==Change.CHANGE_PLACE, Change.recordId == place_id_str) now = datetime.now() for p in place_entries: if p.when < now: p.when = now p.put() user = User.get_by_id(int(user_id_str)) friends_key_list = user.get_friends_key_list() for user_key in friends_key_list: p = Change.\ query( Change.kind == Change.CHANGE_PLACE, Change.subscriberId == str(user_key.id()), Change.recordId == place_id_str).get() if not p: p = Change() p.kind = Change.CHANGE_PLACE p.subscriberId = str(user_key.id()) p.placeId = place_id_str p.when = now p.put() except: logging_ext.error('** AddPlaceChangesWorker', exc_info=True)
def post(self): try: user_id_str = self.request.get('userId') before = datetime.now().strftime(views.config['DATETIME_FORMAT']) taskqueue.add(url='/api/ClearUserChanges', params={}) except: logging_ext.error('** ClearUserUpdates', exc_info=True)
def get(self): place_id = self.request.params['place_id'] logging.debug('getPlaceDetailsApi '+place_id) params = {'placeid': place_id, 'key': config['google_api_key']} url = "https://maps.googleapis.com/maps/api/place/details/json?" + \ urllib.urlencode(params) res = {} try: response = urllib2.urlopen(url) json_result = response.read() details_result = json.loads(json_result) except: logging_ext.error( 'getPlaceDetailFromGoogle: Exception [%s]', place_id, exc_info=True) return {"photo": None, "telephone": None} if details_result['status'] == "OK": if "international_phone_number" in details_result['result']: res['telephone'] = details_result['result']["international_phone_number"] if "website" in details_result['result']: res['website'] = details_result['result']["website"] json.dump(res, self.response.out)
def get(self, key): """ " get a single item """ try: json.dump(Item.id_to_json(key), self.response.out) except: logging_ext.error('updateItem GET Exception '+key,exc_info=True)
def get(self, key): try: photo = ndb.Key(urlsafe=key).get() if photo: self.response.headers['Content-Type'] = 'image/png' self.response.out.write(photo.picture) except: logging_ext.error('ImageHandler '+key, exc_info=True)
def check_good_server_version(request): good_version = False if 'version' in request.params: version = float(request.params['version']) min_version = ndb_models.Config.min_server_version_allowed() if version >= float(min_version): return True if not good_version: logging_ext.error("check_good_server_version BAD VERSION") return False
def get_google_db_places(cls, lat, lng, name, radius): """ do a google geo search :param lat: float :param lng: float :param name: string - to look for :param radius: int - search radius (m) :return: dict - {"item_count": int, "items": []} """ results = {"item_count": 0, "items": []} try: # remove AND or & from name search_words = cls.get_word_list(name) search_text_or = "|".join(search_words) search_text_and = " ".join(search_words) escaped_name = "%s%%7C%s" % (urllib2.quote(search_text_or), urllib2.quote(search_text_and)) url = ("https://maps.googleapis.com/maps/api/place/nearbysearch/" "json?rankby=distance&types=%s&location=%f,%f&name=%s&sensor=false&key=%s")\ % \ (settings.config['place_types'], lat, lng, escaped_name, settings.config['google_api_key'] ) addresses = [] response = urllib2.urlopen(url, timeout=15) jsonResult = response.read() addressResult = json.loads(jsonResult) logging.info("get_google_db_places: Url=%s" % url) except Exception, e: if settings.running_on_test_server(): # make up a test print "get_google_db_places OFFLINE - Making Up Fake Data" addressResult = { 'status': 'OK', 'results': [{ 'formatted_address': '1 Crouch Hill, London', 'name': 'A Madeup Place', 'place_id': '0', 'geometry': { 'location': { 'lat': 54.0 + random(), 'lng': -(1.0 + random()) } } }] } else: logging_ext.error('get_google_db_places Exception in Load', exc_info=True) return None
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 mark_place_as_updated(place_id_str, user_id_str): """ :param place_id_str: string urlsafe :param user_id_str: string urlsafe :return: """ try: taskqueue.add(url='/api/UpdatePlace', params={ 'placeId': place_id_str, 'userId': user_id_str }) except: logging_ext.error('** mark_place_as_updated', exc_info=True)
def post(self): if not check_good_server_version(self.request): self.response.out.write("BAD VERSION") return id = self.request.get('key') it = ndb.Key(Item, int(id)).get() if it: update_votes(it, self, self.user_id) # mark user as dirty self.response.out.write('OK') logging.debug("UpdateVote OK") return logging_ext.error("UpdateVote 404 for %s"%id) self.abort(404)
def handle_verification(cls, handler, user_id,signup_token,verification_type,invite_token): # it should be something more concise like # self.auth.get_user_by_token(user_id, signup_token) # unfortunately the auth interface does not (yet) allow to manipulate # signup tokens concisely user, ts = handler.user_model.get_by_auth_token(int(user_id), signup_token, 'signup') if not user: logging.info( 'Could not find any userId with id "%s" signup token "%s"', user_id, signup_token) handler.display_message("Not found - if you've already followed this link there is no need to do it again") return # store userId data in the session handler.auth.set_session(handler.auth.store.user_to_dict(user), remember=True) if verification_type == 'v': # remove signup token, # we don't want users to come back with an old link handler.user_model.delete_signup_token(handler.user_id, signup_token) if not user.verified: user.verified = True user.put() try: if invite_token and invite_token != 'none': inv = Invite.checkInviteToken(invite_token) Friends.addFriends(inv, handler.user_id) Invite.delInviteToken(invite_token) logging.info("passwordVerificationHandler complete "+user.email_address) except: logging_ext.error( "Failed to add friend: passwordVerificationHandler GET", exc_info=True) handler.render_template('signup-complete.html') elif verification_type == 'p': # supply userId to the page params = { 'userId': user, 'token': signup_token } handler.render_template('resetpassword.html', params) else: logging.info('verification type not supported') handler.abort(404)
def get(self, key): try: photo = ndb.Key(urlsafe=key).get() if photo: self.response.headers['Content-Type'] = 'image/png' self.response.out.write(photo.get_thumb()) else: default_thumb = memcache.get('DEFAULT-THUMB') if not default_thumb: default_thumb = Image() default_thumb.resize(65,55) self.response.headers['Content-Type'] = 'image/png' self.response.out.write(default_thumb) memcache.set('DEFAULT-THUMB', default_thumb) except Exception: logging_ext.error('ThumbHandler '+key, exc_info=True)
def mark_vote_as_updated(vote_id_str, user_id_str): """ :param vote_id_str: string urlsafe :param user_id_str: string urlsafe :return: """ try: now_str = datetime.now().strftime(views.config['DATETIME_FORMAT']) taskqueue.add(url='/api/UpdateVote', params={ 'voteId': vote_id_str, 'userId': user_id_str, 'time': now_str }) except: logging_ext.error('** mark_vote_as_updated', exc_info=True)
def get_updated_places_for_user(user_id_str, since): """ get the list of change records for a given user :param user_id_str: string urlsafe :param since: datetime :return: query object on PlaceChange """ try: result = Change.\ query( Change.kind == Change.CHANGE_PLACE, Change.subscriberId==user_id_str, Change.when > since) return result except: logging_ext.error('** get_updated_places_for_user', 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 post(self): # should run at most 1/s due to entity group limit """ Deletes all records of updated votes & places for the given user more than n days old """ try: since = datetime.now() - timedelta( days=settings.config['updates_max_age']) # @ndb.transactional old_votes = Change.\ query(Change.kind==Change.CHANGE_VOTE, Change.when < since).\ fetch(keys_only=True) ndb.delete_multi(old_votes) old_places = Change.\ query(Change.kind==Change.CHANGE_VOTE, Change.when < since).\ fetch(keys_only=True) ndb.delete_multi(old_places) logging.info("ClearUserChangesWorker") except: logging_ext.error('** ClearUserChangesWorker', exc_info=True)
def get(self): try: logging.debug('getStrangerPlaces') lat = float(self.request.get("lat")) lng = float(self.request.get("lng")) place_names = [] results = geo.findDbPlacesNearLoc(geo.LatLng(lat=lat, lng=lng), place_names=place_names) if results: results['search'] = {'lat': lat, 'lng': lng} # check_for_dirty_data(self, results) json.dump(results, self.response.out, default=views.json_serial) else: # logging.info("get_google_db_places near [%f,%f]: %s" % # (lat, lng, "none found")) logging.debug("getStrangerPlaces - none found ") self.error(401) except Exception: logging_ext.error("getStrangerPlaces", True)
def get(self): con = {"email": Category.query()} tok_list = ",".join(self.request.GET) logging_ext.info('FbRedirect: Params '+tok_list) try: # get the token token = self.request.params["access_token"] # is the email a user? # email not known # check if token is registered for user # if not, store it # log the user logging.info('FbRedirect: Logged in') con['message'] = "Logged in using facebook" self.render_template("oauth-fb.html", con) except: logging_ext.error("Unable to read data", exc_info=True) con['message'] = "Unable to read data" self.render_template("oauth-fb.html", con)
def getFullUserRecord(self, user, now=None): try: places_id2json = {} vote_list = [] if settings.config['all_are_friends']: q = User.gql('') else: # start with me q = [user] # then get my friends for f in user.get_friends_key_list(): q.append(f.get()) place_json = None place_id = None for u in q: if u: user_votes = models.Vote.query( models.Vote.voter == u.key.integer_id()).fetch() for vote in user_votes: try: place_id = vote.item.id() vote_list.append(vote.get_json()) if not place_id in places_id2json: place_json = models.Item.id_to_json(place_id) if "cuisineName" in place_json: places_id2json[place_id] = place_json except Exception, e: if place_json: logging_ext.error( "** getFullUserRecord Exception 1 %s" % place_json['place_name'], exc_info=True) else: logging_ext.error( "** getFullUserRecord Exception %s" % place_id, exc_info=True) return vote_list, places_id2json
def post(self): #https://cloud.google.com/appengine/docs/python/ # appidentity/#Python_Asserting_identity_to_other_App_Engine_apps logging.debug("UpdateItemFromAnotherAppAPI") #TODO: Security #if app_identity.get_application_id() != settings.API_TARGET_APP_ID: # logging.debug("UpdateItemFromAnotherAppAPI 403: %s != %s"%\ # (app_identity.get_application_id(),settings.API_TARGET_APP_ID)) # self.abort(403) #app_id = self.request.headers.get('X-Appengine-Inbound-Appid', None) #logging.info('UpdateItemFromAnotherAppAPI: from app %s'%app_id) #if app_id in settings.ALLOWED_APP_IDS: if True: seed_user = None for u in User.query(): if 'pegah' in u.auth_ids: seed_user = u.key.id() break if seed_user: logging.debug("UpdateItemFromAnotherAppAPI user:"******"" for k in self.request.params: params += '"%s": "%s"'%(k, self.request.params[k]) logging.debug("UpdateItemFromAnotherAppAPI params: "+params) if update_item_internal(self, seed_user, allow_update=False): logging.debug("UpdateItemFromAnotherAppAPI Done ") else: logging.debug("UpdateItemFromAnotherAppAPI Existed ") self.response.out.write("OK") else: logging_ext.error("UpdateItemFromAnotherAppAPI - couldn't get seed user", exc_info=True) self.abort(500) else: logging.debug("UpdateItemFromAnotherAppAPI not allowed") self.abort(403)
def post(self): # should run at most 1/s due to entity group limit """ Task Worker to mark votes as updated - deletes all entries for the vote - adds a new one for all friends of voter Params: voteId: string userId: string """ try: logging_ext.log_to_console('AddVoteChangesWorker IN') vote_id_str = self.request.get('voteId') if not vote_id_str: logging_ext.error("** AddVoteChangesWorker: no vote id") return user_id_str = self.request.get('userId') if not user_id_str: logging_ext.error("** AddVoteChangesWorker: no user_id") return user_id = int(user_id_str) me = User.get_by_id(user_id) time = self.request.get('time') old_votes = Change.\ query(Change.kind == Change.CHANGE_VOTE, Change.recordId == vote_id_str).\ fetch(keys_only=True) ndb.delete_multi(old_votes) friends_list = me.get_friends_key_list() for u in friends_list: change = Change() change.kind = Change.CHANGE_VOTE change.recordId = vote_id_str change.subscriberId = str(u.id()) change.when = datetime.strptime( time, views.config['DATETIME_FORMAT']) change.put() except Exception: logging_ext.error("** AddVoteChangesWorker", exc_info=True)
'cuisineName': "", 'telephone': '', 'img': '', 'edited': 0, 'thumbnail': '', 'up': 0, 'down': 0, 'owner': None, # is_map is True if the point came # from a google places API search. Default False 'is_map': True } addresses.append(detail) results["item_count"] += 1 results['items'] = addresses return results except Exception, e: logging_ext.error('get_google_db_places Exception processing', exc_info=True) return results elif addressResult['status'] == "ZERO_RESULTS": logging.info("get_google_db_places near [%f,%f]: %s - %s" % (lat, lng, name, addressResult['status']), exc_info=True) return results else: logging_ext.error("get_google_db_places near [%f,%f]: %s" % (lat, lng, addressResult['status']), exc_info=True) return results
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=views.json_serial) return if my_id: try: # logged in #check if the client version is allowed good_version = False if 'version' in self.request.params: version = float(self.request.params['version']) min_version = Config.min_server_version_allowed() if version >= float(min_version): good_version = True if not good_version: logging_ext.error( "getUserRecordFastViaWorkers BAD VERSION") self.response.out.write("BAD_VERSION") return #good client version if we got here result = { "id": my_id, "admin": self.user.profile().is_admin, "version": settings.config["version"], "min_version": settings.config['min_version'] } since = None now = datetime.now() if 'since' in self.request.params: try: # move since back in time to allow for error since = datetime.strptime( self.request.params['since'], views.config['DATETIME_FORMAT']) - \ views.config['TIMING_DELTA'] vote_list, place_id2json = self.getIncrement( my_id, since) except OverflowError, ex: logging_ext.error( "** getFullUserRecord Time error with %s" % since, exc_info=True) #full update vote_list, place_id2json = self.getFullUserRecord( self.user) else: #full update vote_list, place_id2json = self.getFullUserRecord( self.user) friends_list = [] if views.config['all_are_friends']: q = User.gql('') for u in q: user_str = { "id": u.get_id(), # todo is it first_name? 'name': u.screen_name } friends_list.append(user_str) else: friends = self.user.get_friends_key_list() for f in friends: friend = f.get() try: user_str = { "id": f.id(), # todo is it first_name? 'name': friend.screen_name } except: logging.error("getFullUserRecord Friends error") friends_list.append(user_str) sentInvites = models.InviteInternal.query( models.InviteInternal.inviter == my_id) recdInvites = models.InviteInternal.query( models.InviteInternal.invitee == my_id) sent = [] for i in sentInvites: sent.append(i.to_json()) recd = [] for i in recdInvites: recd.append(i.to_json()) result["sentInvites"] = sent result["receivedInvites"] = recd result['votes'] = vote_list result["places"] = place_id2json result["friendsData"] = friends_list json_str = json.dumps(result, default=views.json_serial) try: since_str = str(since) if since else "" logging.debug( "GetFullUserRecord for %s %s P:%d, V:%d, F:%d" % (self.user.screen_name, since_str, len(place_id2json), len(vote_list), len(friends_list))) except: pass try: #logging logging.debug("getUserRecordFastViaWorkers done ") except: pass self.response.out.write(json_str) #profile_out("getFullUserRecord") return
def update_item_internal(self, user_id, allow_update=True): def update_field(field_name, value): # so we can log edits old_val = getProp(it,field_name) if old_val != value: setattr(it,field_name,value) changed[field_name]="%s->%s"%(old_val,value) # is it an edit or a new? it = Item.get_unique_place(self.request, allow_update) if not it: # it will be None if it exists and not allow_update return None img = update_photo(it, self) # it.place_name = self.request.get('new-title') set in get_unique_place changed = {} update_field ('address', self.request.get('address')) it.owner = user_id if img: it.photo = img else: if not it.photo or not it.website: #TODO: make this async: load one from google detail = geo.getPlaceDetailFromGoogle(it) if not it.photo: img = DBImage() remoteURL = detail['photo'] if remoteURL: thumb_url=None try: main_url = remoteURL % 250 data = urllib2.urlopen(main_url) img.picture = db.Blob(data.read()) img.remoteURL = None thumb_url = remoteURL % 65 thumb_data = urllib2.urlopen(thumb_url) img.thumb = db.Blob(thumb_data.read()) img.put() it.photo = img.key except: if thumb_url: logging_ext.error("update_item_internal: remote url ["+str(thumb_url)+"] Exception", exc_info=True) else: logging_ext.error("update_item_internal: remote url Exception", exc_info=True) it.photo = None if 'telephone' in detail and detail['telephone'] != None: it.telephone = detail['telephone'] if 'website' in detail and detail['website']: it.website = detail['website'] if not it.telephone: it.telephone = self.request.get('telephone') if not it.website: it.website = self.request.get('website') # category posted_cat = self.request.get("cuisine") try: cat_key = ndb.Key(Category,posted_cat) except: cat_key = None update_field('category', cat_key) if "place_name" in self.request.params: update_field('place_name', self.request.params['place_name']) it.put() # so the key is set # refresh cache update_votes(it, self, user_id) # todo: why? logging.info("update_item_internal for "+it.place_name+": "+str(changed)) return it
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)
def get(self): """ get the entire 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: #profile_in("getFullUserRecord") user = User.get_by_id(my_id) if user: # logged in 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'] # is it for a specific user? if "forUser" in self.request.params: for_1_user = long(self.request.get("forUser")) else: for_1_user = None # either the first lookup is for me, plus everyone, # or it is for a specified user result = { "id": my_id, "admin": self.user.profile().is_admin } if for_1_user: logging.info("getFullUserRecord: 1 user") first_user = for_1_user result["for_1_user"] = for_1_user else: logging.info("getFullUserRecord: 1+ user") first_user = my_id dict_id_place = {} # load the data for the 1 user - me or specified friends_data = [ serialize_user_details( first_user, dict_id_place, my_id, self.request, since)] # was it for all users? If so we've only done ourselves if not for_1_user: # for all users prof = user['p'] if config['all_are_friends']: q = User.gql('') logging.info("getFullUserRecord: %d friends"%q.count()) for user in q: # for userProf in UserProfile().all(): if user.get_id() == my_id: continue # don't add myself again data = serialize_user_details( user.get_id(), dict_id_place, my_id, self.request, since) logging.info("getFullUserRecord: record %s"%data) friends_data.append(data) else: for friend in prof.friends: friends_data.append(serialize_user_details( friend, dict_id_place, my_id, self.request, since)) result["friendsData"] = friends_data logging.debug('getFullUserRecord: return %d places'%len(dict_id_place)) result["places"] = dict_id_place # encode using a custom encoder for datetime json_str = json.dumps( result, default=json_serial) self.response.out.write(json_str) #profile_out("getFullUserRecord") return self.error(401)
Change.subscriberId == str(my_id), Change.when > since) for uv in updated_votes: key = ndb.Key('Vote', int(uv.voteId)) v = key.get() if v: try: vote_list.append(v.json) place_id = v.item.id() if not place_id in places_id2json: places_id2json[place_id] = v.item.get().get_json() except Exception, E: pass return vote_list, places_id2json except: logging_ext.error('** getIncrement', exc_info=True) def getFullUserRecord(self, user, now=None): try: places_id2json = {} vote_list = [] if settings.config['all_are_friends']: q = User.gql('') else: # start with me q = [user] # then get my friends for f in user.get_friends_key_list(): q.append(f.get()) place_json = None place_id = None