def get_data(self):
""" Returns the list of restaurants tagged to this user.
Searches the data store to return data about the user's bookmarked
restaurants, as well as which restaurants the user has been invited to.
Additionally, the invited friends list and owner for each restaurant
bookmark returned is populated with data before being rendered, so owners
and invitees can be rendered.
Returns:
A dict containing the restaurant data for this user.
"""
data = super(JsonRestaurantsView, self).get_data()
provider = restaurants.LabelProvider()
viewer = self.request.users.get_viewer()
labels = provider.get_by_user(viewer)
for label in labels:
invitees = self.request.users.get_users_by_key_name(
label.invited_guids)
if invitees:
label.invitees = invitees.itervalues()
invites = provider.get_by_invitee(viewer)
if invites:
for invite in invites:
invite.user = self.request.users.get_user_by_key_name(
invite.user.guid)
data.update({
"labels": labels,
"invites": invites,
})
return data
def delete(self):
""" Deletes a restaurant bookmark from the current user's list. """
viewer = self.request.users.get_viewer()
label_provider = restaurants.LabelProvider()
params = self.require_parameters("key")
label = label_provider.get_by_key(params["key"])
if label and label.user == viewer:
label.delete()
self.render()
def _get_session_provider(self):
""" Returns an initialized session provider.
This method will attempt to continue an existing session based off of
cookie data in the request. If multiple sessions are found, this method
will attempt to obtain viewers for each session. If multiple viewers
are found, their accounts will be merged, so this function has
significant side effects in certain cases!
If no session is found, then a new session is created.
Returns:
A session provider that can be used to store data for the current viewer
across several requests.
"""
local_session = None
remote_session = None
cookies = self.request.cookies
cookie = settings.SESSION_COOKIE_NAME
if cookies.has_key(cookie):
logging.info("Continuing local session (%s)" % cookies[cookie])
local_session = sessions.SessionProvider(cookies[cookie])
cookie = settings.FRIENDCONNECT_COOKIE_NAME
if cookies.has_key(cookie):
key = hashlib.sha1(cookies[cookie]).hexdigest()
logging.info("Continuing remote session (%s)" % key)
remote_session = sessions.SessionProvider(key)
if remote_session and local_session:
remote_viewer = remote_session["viewer"]
local_viewer = local_session["viewer"]
if remote_viewer:
logging.info("Remote viewer: %s" % remote_viewer.display_name)
if local_viewer:
logging.info("Local viewer: %s" % local_viewer.display_name)
if remote_viewer and local_viewer:
logging.info("Logged in twice, merging accounts")
# TODO: Move this logic somewhere else and remove the restaurants import
restaurants.LabelProvider().move_user_data(
local_viewer, remote_viewer)
remote_viewer.merge(local_viewer)
local_session.kill()
local_session = None
self.set_cookie(settings.SESSION_COOKIE_NAME, "", -1)
self.redirect("/")
if not remote_session and not local_session:
local_session = sessions.SessionProvider()
cookie_value = urllib.quote_plus(local_session.key)
self.set_cookie(settings.SESSION_COOKIE_NAME, cookie_value)
logging.info("Starting local session (%s)" % local_session.key)
# TODO: Prefer the local session if a gfc viewer does not exist
return remote_session or local_session
def post(self):
""" Adds a new restaurant bookmark for the current user. """
params = self.require_parameters("restaurant_id")
viewer = self.request.users.get_viewer()
label_provider = restaurants.LabelProvider()
restaurant_provider = restaurants.RestaurantProvider()
restaurant = restaurant_provider.get_restaurant(
params["restaurant_id"])
label_provider.set(viewer, restaurant, "try")
self.render()
def post(self):
""" Handles the response from the invite form.
This method adds a posted list of comma separated friend guids to a given
invite. Both of these identifiers come from the POST request.
"""
params = self.require_parameters("label_id")
invited_ids = self.request.get("invited_ids", None)
if invited_ids:
invited_ids = invited_ids.split(",")
else:
invited_ids = []
logging.info("invited_ids: %s" % invited_ids)
label = restaurants.LabelProvider().get_by_key(params["label_id"])
if label and label.user == self.request.users.get_viewer():
label.invited_guids = invited_ids
label.put()
self.render()
def __populate_data(self):
""" Get data about the viewer's friends. """
if self.__friends is None:
try:
self.__count = int(self.request.get("count"))
except:
self.__count = settings.FRIEND_PAGE_SIZE
try:
self.__start = int(self.request.get("start"))
except:
self.__start = 0
self.__friends = self.request.users.get_viewer_friends(
self.__start, self.__count)
label_provider = restaurants.LabelProvider()
if self.__friends:
for friend in self.__friends:
labels = label_provider.get_by_user(friend)
if labels:
friend.labels = labels