def post(self):
if self.request.get('_put'):
self.put()
return
name = self.request.get('name')
member_ids = self.request.get_all('member_uuid')
public = self.request.get('public')
user = api.get_user(self.request)
if not user:
api.write_error(self.response, 400, 'Unknown or missing user')
return
group = Group(uuid=str(uuid.uuid4()))
group.admins.append(user.key)
group.members.append(user.key)
group.name = name
if 'public' in self.request.params and not public == '':
group.public = public.lower() in ("yes", "true", "t", "1", "on")
for member_id in member_ids:
member = User.query(User.uuid == member_id).get()
if member:
group.members.append(member.key)
group.put()
if group.public:
api.search.update_public_index(group)
else:
api.search.update_private_index(group, user.uuid)
api.write_message(self.response, 'success', extra={'groups' : [ get_group_json(group) ]})
def get(self, recipe_id):
# check if ID is found in recipe database
recipe = Recipe.get_by_id(int(recipe_id))
if not recipe :
error = "That recipe was not found."
template_values = { 'error' : error }
else :
# check if this recipe belongs to user
if recipe.author == UserId() :
isOwner = True
else :
isOwner = False
recipe_author_name = User.query().filter(User.user_id == recipe.author).fetch(1)[0].name
recipe_author_pic = User.query().filter(User.user_id == recipe.author).fetch(1)[0].picUrl()
template_values = { 'recipe_author_pic' : recipe_author_pic, 'title': recipe.name, 'recipe' : recipe, 'isOwner' : isOwner, 'header': GetHeader('recipe'), 'recipe_author_name': recipe_author_name }
IndividualRecipe = jinja_environment.get_template('templates/recipes_individual.html').render(template_values)
self.response.write(IndividualRecipe)
def get_user(request):
try:
auth_header = request.headers['Authorization']
except KeyError:
auth_header = request.get('auth')
if auth_header:
uuid, auth = get_uuid_auth(auth_header)
if uuid and auth:
user = User.query(User.uuid == uuid).get()
if user and user.auth == auth:
return user
return None
def get(self):
uuid = self.request.get('uuid')
user = api.get_user(self.request)
if not user:
api.write_error(self.response, 403, 'Unknown or missing user')
return
json = None
if uuid:
other = User.query(User.uuid == uuid).get()
if other:
json = get_user_json(other)
if not json:
json = get_user_json(user, public=False)
api.write_message(self.response, 'success', extra={'users' : [json]})
def get(self):
# check if user is already in database
rawRecipes = Recipe.query().fetch()
recipes = []
for rawRecipe in rawRecipes :
if rawRecipe.image :
recipes.append({
'name': rawRecipe.name,
'latlng': str(rawRecipe.location),
'location': rawRecipe.location_name,
'cooktime': rawRecipe.cooktime,
'image': '<div style="background-image: url(' + rawRecipe.imageUrl() + ')"></div>',
'servings': rawRecipe.servings,
'ingredients': json.dumps(rawRecipe.ingredients),
'recipeUrl' : rawRecipe.viewUrl()
})
else :
recipes.append({
'name': rawRecipe.name,
'latlng': str(rawRecipe.location),
'location': rawRecipe.location_name,
'cooktime': rawRecipe.cooktime,
'servings': rawRecipe.servings,
'ingredients': json.dumps(rawRecipe.ingredients),
'recipeUrl' : rawRecipe.viewUrl()
})
user = users.get_current_user()
name = user.nickname()
userID = user.user_id()
dbUser = User.query().filter(User.user_id == userID).fetch(1)
if UserInfo() :
name = dbUser[0].name
template_values = { 'name': name }
firstTime = False
else :
newUser = User(user_id=userID, name=name, savedRecipes=[''])
newUser.put()
name = user.nickname()
firstTime = True
template_values = { 'title': 'Homepage', 'recipes': json.dumps(recipes), 'header': GetHeader('homepage'), 'logout_url': users.create_logout_url('/'), 'first_time': firstTime }
Homepage = jinja_environment.get_template('templates/homepage.html').render(template_values)
self.response.write(Homepage)
def post(self):
data = json.loads(self.request.body)
recipe = Recipe.get_by_id(int( data['recipeID'] ))
# check if user has already saved this recipe
dbUser = User.query().filter(User.user_id == UserId()).fetch(1)
user = dbUser[0]
matches = 0
for savedRecipe in user.savedRecipes :
if savedRecipe == data['recipeID'] :
matches += 1
break;
if matches == 0 :
if recipe.thumbsUp == None :
recipe.thumbsUp = 1
else :
recipe.thumbsUp += 1
recipe.put()
user.savedRecipes.append( data['recipeID'] );
user.put()
self.response.write(json.dumps(({'recipe_thumbsUp': recipe.thumbsUp, 'net_thumbs': recipe.thumbsUp})))
def get(self, author_id):
# check if there is user that corresponds with the ID
author = User.query().filter(User.user_id == author_id).fetch()
if author :
# check if the user has any recipes
recipes = Recipe.query().filter(Recipe.author == author_id).fetch()
if recipes :
template_values = { 'header': GetHeader('recipe'), 'recipes' : recipes, 'author' : author[0].name ,'author_bio' : author[0].bio , 'title' : 'Recipes by ' + author[0].name}
if author[0].pic :
template_values['author_pic'] = author[0].picUrl()
if author[0].location :
template_values['author_location'] = author[0].location
else :
error = "This user has not uploaded any recipes."
template_values = { 'header': GetHeader('recipe'), 'title': 'Error', 'error' : error }
else :
error = "This user doesn't not exist."
template_values = { 'header': GetHeader('recipe'), 'title': 'Error', 'error' : error }
RecipesBy = jinja_environment.get_template('templates/recipes_by.html').render(template_values)
self.response.write(RecipesBy)
def get(self):
tags = self.request.get('tags')
public = self.request.get('public')
user = api.get_user(self.request)
if not user:
api.write_error(self.response, 400, 'Unknown or missing user')
return
if public:
user = User.query(User.uuid == config.SUPER_USER_UUID).get()
cards = []
if tags:
tags = tags.lower().split(',')
query = Card.query(Card.tags.IN(tags),
ancestor=user.key).order(-Card.create_time)
else:
query = Card.query(ancestor=user.key).order(-Card.create_time)
for card in query:
cards.append(get_card_json(card))
api.write_message(self.response, 'success', extra={'cards': cards})
def UserInfo() : user = users.get_current_user() name = user.nickname() userID = UserId() dbUser = User.query().filter(User.user_id == userID).fetch(1) return dbUser
def load_user_obj(self, user_name):
logging.info("Trying to load user with user name - " +
user_name.lower())
self.user_obj = User.query(User.name == user_name.lower()).get()
def post(self):
email = self.request.get('email')
push_token = self.request.get('token')
device_type = self.request.get('type')
user_uuid = self.request.get('uuid')
code = self.request.get('code')
if user_uuid and code:
code = int(code)
user = User.query(User.uuid == user_uuid).get()
if not user or not user.recovery:
api.write_error(self.response, 404, 'User not found')
return
if not user.recovery.code == code:
api.write_error(self.response, 403, 'Invalid recovery code')
return
if (datetime.datetime.now() - user.recovery.time).seconds > (15 * 60):
api.write_error(self.response, 403, 'Old recovery code')
return
user.auth = str(uuid.uuid4())
user.put()
api.write_message(self.response, 'success',
extra={'users' : [get_user_json(user, public=False)]})
return
users = User.query(User.devices.data == email)
if not users or users.count(limit=1) < 1:
api.write_error(self.response, 404, 'User not found')
return
extra = {}
push_token_found = False;
first_user = None
for user in users:
if not user or not user.devices:
continue
if not first_user:
first_user = user
for device in user.devices:
if not device.device_type in ['GOOGLE', 'APPLE', 'AMAZON']:
continue
if device.device_type == device_type and device.data == push_token:
push_token_found = True
if device.device_type == 'GOOGLE':
user.auth = str(uuid.uuid4())
user.put()
user_json = get_user_json(user, public=False)
user_json['cards'] = []
api.gcm([push_token], {'user': user_json})
elif device.device_type == 'APPLE':
# Until we can deliver data to iOS app directly, use email for them
push_token_found = False
if not push_token_found and first_user:
# Is this correct to pick first user?
if not first_user.recovery:
first_user.recovery = Recovery()
first_user.recovery.code = random.randint(1000, 9999)
api.email(email, config.EMAIL_RECOVERY_SUBJECT,
config.EMAIL_RECOVERY_BODY % (first_user.recovery.code))
first_user.put()
extra = {'users' : [get_user_json(first_user)]}
api.write_message(self.response, 'success', extra=extra)
def put(self):
uuid = self.request.get('group_uuid')
name = self.request.get('name')
admin_ids = self.request.get_all('admin_uuid')
member_ids = self.request.get_all('member_uuid')
public = self.request.get('public')
if not uuid:
api.write_error(self.response, 400, 'Missing required parameter, group_uuid')
return
user = api.get_user(self.request)
if not user:
api.write_error(self.response, 403, 'Unknown or missing user')
return
group = Group.query(Group.uuid == uuid).get()
if not group:
api.write_error(self.response, 404, 'Unknown or missing group')
return
if not user.key in group.admins:
api.write_error(self.response, 403, 'User not allowed to update group')
return
if name:
group.name = name
if 'public' in self.request.params and not public == '':
group.public = public.lower() in ("yes", "true", "t", "1", "on")
for admin_id in admin_ids:
remove_user = False
if admin_id and admin_id[0] == '-':
remove_user = True
admin_id = admin_id[1:]
admin = User.query(User.uuid == admin_id).get()
if admin:
if remove_user and admin.key in group.admins:
if len(group.admins) > 1:
group.admins.remove(admin.key)
else:
api.write_error(self.response, 403, 'Cannot remove last admin')
return
elif not admin.key in group.admins:
group.admins.append(admin.key)
else:
logging.warn('Unknown user %s' % (admin_id))
for member_id in member_ids:
remove_user = False
if member_id and member_id[0] == '-':
remove_user = True
member_id = member_id[1:]
member = User.query(User.uuid == member_id).get()
if member:
if remove_user and member.key in group.members:
group.members.remove(member.key)
elif not member.key in group.members:
group.members.append(member.key)
else:
logging.warn('Unknown user %s' % (member_id))
group.put()
if group.public:
api.search.update_public_index(group)
else:
api.search.update_private_index(group, user.uuid)
api.write_message(self.response, 'Updated group',
extra={'groups' : [ get_group_json(group) ]})
