def test_liking_image(self):
"""
admin creates a sharedfile. Joe (authenticated) likes it.
Response should be successful and include following fields:
{
'response' : 'ok',
'count' : 1,
'share_key', 1
}
A new entry should be present in favorites table. like_count on the sharedfile
should be incremented.
"""
sharedfile = self._create_sharedfile(self.admin)
self.sign_in('joe', 'asdfasdf')
favorite = Favorite.get('user_id = %s and sharedfile_id = %s' %
(self.joe.id, sharedfile.id))
self.assertEqual(None, favorite)
self.assertEqual(0, sharedfile.like_count)
response = self.post_url('/p/%s/like?json=1' % sharedfile.share_key)
json_response = json.loads(response.body)
self.assertEqual(json_response['response'], 'ok')
self.assertEqual(json_response['count'], 1)
self.assertEqual(json_response['share_key'], sharedfile.share_key)
favorite = Favorite.get('user_id = %s and sharedfile_id = %s' %
(self.joe.id, sharedfile.id))
self.assertTrue(favorite)
sharedfile_fetched = Sharedfile.get("id = %s", sharedfile.id)
self.assertEqual(1, sharedfile_fetched.like_count)
def favorite():
"""Favorite a song."""
user = g.user
if not user:
flash('Sign in or sign up to favorite', 'dark')
return redirect('/sign-up')
song_key = request.json['key']
song_fav = Favorite(user_id=user.id, song_key=song_key)
add_to_songs(song_key)
user.favorites.append(song_fav)
try:
db.session.commit()
return jsonify(action='favorited')
except (IntegrityError, FlushError):
db.session.rollback()
song_fav = Favorite.query.filter_by(user_id=user.id, song_key=song_key)
song_fav.delete()
db.session.commit()
return jsonify(action='unfavorited')
def setup_fav(self):
f1 = Favorite(rest_id=self.testrest.id,
rest_name='Yummy',
user_id=8989)
f2 = Favorite(rest_id=self.r1_id, rest_name="Sushi", user_id=8989)
db.session.add_all([f1, f2])
db.session.commit()
def favorites_action(self, product, action):
actions = ["add", "remove"]
if action not in actions:
abort(404)
found_product = self.retrieve_product(product)
if type(found_product) is not str:
db_name = found_product.db_name
api_call = getattr(g.db, db_name).find_one({"_id": ObjectId(request.json.get("call_id"))})
if not api_call:
abort(404)
user_favorites = g.db.favorites.find_one({"username": session.get("username")})
if not user_favorites and action == "add":
user_favorites = {"username": session.get("username")}
elif user_favorites is None:
return jsonify(code=200)
favorite = Favorite(user_favorites)
if action == "add":
favorite.add_to_favorites(
request.json.get("call_id"), db_name, found_product.app_url, session.get("username")
)
elif action == "remove":
favorite.remove_favorite(request.json.get("call_id"), session.get("username"))
return jsonify(code=200)
abort(404)
def favorite_creator(num_favorites):
for i in range(num_favorites):
Favorite.create(
uuid=fake.uuid4(),
item=Item.select().order_by(fn.Random()).get(),
user=User.select().order_by(fn.Random()).get(),
)
def create_tables():
User.create_table(fail_silently=True)
Item.create_table(fail_silently=True)
Address.create_table(fail_silently=True)
Order.create_table(fail_silently=True)
OrderItem.create_table(fail_silently=True)
Picture.create_table(fail_silently=True)
Favorite.create_table(fail_silently=True)
def favorite_insert(self, favorite):
if favorite.from_datastore:
favorite_with_parent = favorite
else:
favorite_with_parent = Favorite(parent=main.get_parent_key(endpoints.get_current_user()),
company_entity_key = favorite.company_entity_key)
favorite_with_parent.put()
return favorite_with_parent
def favorite_insert(self, favorite):
if favorite.from_datastore:
favorite_with_parent = favorite
else:
favorite_with_parent = Favorite(
parent=main.get_parent_key(endpoints.get_current_user()),
company_entity_key=favorite.company_entity_key)
favorite_with_parent.put()
return favorite_with_parent
def favorite_for_company(self, request):
user = endpoints.get_current_user()
query = Favorite.query(ancestor=main.get_parent_key(user)).filter(
Favorite.company_entity_key == request.company_entity_key)
returnFavorite = Favorite(message="null")
for favorite in query:
returnFavorite = favorite
break
return returnFavorite
def delete_user(id):
User.delete().where(User.id == id).execute()
Media.delete().where(Media.user_id == id).execute()
Favorite.delete().where(Favorite.user_id == id).execute()
Comment.delete().where(Comment.user_id == id).execute()
return jsonify(data={},
status={
'code': 200,
'message': 'User deleted from all resources'
})
def setUp(self):
"""Add sample user/post/fav"""
User.query.delete()
Post.query.delete()
Favorite.query.delete()
# create test user
u1 = User.signup(display_name='test1',
username='******',
password="******",
caption="i am test user 1")
u2 = User.signup(display_name='test2',
username='******',
password="******",
caption="test2")
u3 = User.signup(display_name='test3',
username='******',
password="******",
caption="im tester 3")
db.session.add(u1)
db.session.add(u2)
db.session.add(u3)
db.session.commit()
self.u1 = u1
self.u1_id = u1.id
self.u2_id = u2.id
self.u3_id = u3.id
# create test post for test user
p1 = Post(title="test title", image="https://images.unsplash.com/photo-1509840841025-9088ba78a826?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=1350&q=80", description="This is a test2", lat=38.9196, lng=-2.0507, created_dt="2021-03-16 10:45:53.875247", place_name="Testopia", user_id=self.u1.id)
db.session.add(p1)
db.session.commit()
self.p1_id = p1.id
self.p1_title = p1.title
self.p1_user = p1.user_id
f1 = Favorite(post_id=self.p1_id, user_id=self.u1_id)
f2 = Favorite(post_id=self.p1_id, user_id=self.u2_id)
f3 = Favorite(post_id=self.p1_id, user_id=self.u3_id)
db.session.add(f1)
db.session.add(f2)
db.session.add(f3)
db.session.commit()
def post_favorite():
if not request.json or not 'user_id' in request.json or not 'article_id' in request.json:
abort(400)
user_id = request.json['user_id']
article_id = request.json['article_id']
from models import Favorite
obj = Favorite.objects(user_id=user_id)
if obj:
favorite = obj.get()
else:
favorite = Favorite(user_id=user_id)
favorite.article_list.append(article_id)
favorite.article_list.sort(reverse=True)
favorite.save()
return jsonify({"response_msg": "success", "response_code": 201}), 201
def add_favorite(user, item, id=None):
"""Link the favorite item to user."""
return Favorite.create(
uuid=id or uuid.uuid4(),
item=item,
user=user,
)
def add_favorite(bot, update, item: Bot, callback_alert=None):
user = User.from_update(update)
uid = util.uid_from_update(update)
mid = util.mid_from_update(update)
from components.basic import main_menu_buttons
main_menu_markup = ReplyKeyboardMarkup(main_menu_buttons(uid in settings.MODERATORS))
fav, created = Favorite.add(user=user, item=item)
if created:
Statistic.of(user, 'add-favorite', item.username)
text = mdformat.love("{} added to your {}favorites.".format(fav.bot, '' if callback_alert else '/'))
if callback_alert:
update.callback_query.answer(text=text, show_alert=False)
else:
msg = util.send_md_message(bot, uid, text, to_edit=mid, reply_markup=main_menu_markup)
mid = msg.message_id
util.wait(bot, update)
send_favorites_list(bot, update, to_edit=mid)
else:
text = mdformat.none_action(
"{} is already a favorite of yours.{}".format(fav.bot, '' if callback_alert else ' /favorites'))
if callback_alert:
update.callback_query.answer(text=text, show_alert=False)
else:
util.send_md_message(bot, uid, text, reply_markup=main_menu_markup)
return ConversationHandler.END
def test_unliking_image(self):
"""
admin creates a sharedfile. Joe likes it. Then, joe decides to unlike it.
Unliking an already liked image, should result in following response:
{
'response' : 'ok',
'count' : 0,
'share_key', 1
}
An entry should still be present in Favorites table, with deleted = 1.
Like count should be reset on the sharedfile.
"""
sharedfile = self._create_sharedfile(self.admin)
self.joe.add_favorite(sharedfile)
sharedfile_fetched = Sharedfile.get("id = %s", sharedfile.id)
self.assertEqual(1, sharedfile_fetched.like_count)
self.sign_in('joe', 'asdfasdf')
response = self.post_url('/p/%s/unlike?json=1' % sharedfile.share_key)
json_response = json.loads(response.body)
self.assertEqual(json_response['response'], 'ok')
self.assertEqual(json_response['count'], 0)
self.assertEqual(json_response['share_key'], sharedfile.share_key)
favorite = Favorite.get('user_id= %s and sharedfile_id = 1' %
self.joe.id)
self.assertTrue(favorite)
self.assertTrue(favorite.deleted)
sharedfile_fetched = Sharedfile.get("id = %s", sharedfile.id)
self.assertEqual(0, sharedfile_fetched.like_count)
def fav_post(post_id):
"""Handle likes for a post"""
if g.user:
user = g.user.id
post_favs = msg = Favorite.query.filter(
Favorite.post_id == post_id).all()
user_faved = [f.user_id for f in post_favs]
# check if user id is in the users that favorited the post
if user in user_faved:
msg = Favorite.query.filter(Favorite.post_id == post_id,
Favorite.user_id == user).delete()
db.session.commit()
# if user has not favorited
else:
f = Favorite(post_id=post_id, user_id=user)
db.session.add(f)
db.session.commit()
return redirect(f"/post/{post_id}")
# Throw warning if there is no user
else:
flash("Please login or create an account to favorite this post!",
"danger")
return redirect(f"/post/{post_id}")
def add_favorite(drink_id):
"""Favorite drink with current user."""
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
user = g.user
new_drink = Drink(id=drink_id)
db.session.add(new_drink)
db.session.commit()
favorited = [f.id for f in user.favorites]
favorited_drinks = Drink.query.filter(Drink.id.in_(favorited)).all()
if drink_id in favorited:
favorite = Favorite.query.filter(
Favorite.user_id == user.id,
Favorite.drink_id == drink_id).first()
db.session.delete(favorite)
db.session.commit()
return redirect("/")
new_favorite = Favorite(user_id=g.user.id, drink_id=drink_id)
db.session.add(new_favorite)
db.session.commit()
return redirect(f"/users/{user.id}")
def test_favorites_for_user(self):
"""
Returns favorites for user, sorted in reverse order of when they were added.
TODO: test the before_id & after_id parameters.
"""
new_user = User(name='new_user',
email='*****@*****.**',
verify_email_token='created',
email_confirmed=0,
is_paid=1)
new_user.save()
another_sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file",user_id=self.user.id, \
content_type="image/png", share_key="ok", description="some\ndescription\nhere", source_url="https://www.mltshp.com/?hi")
another_sharedfile.save()
#one favorite shared file
new_user.add_favorite(self.sharedfile)
new_user.add_favorite(another_sharedfile)
#this should only return one, since we don't dupe source_ids
sfs = Sharedfile.favorites_for_user(new_user.id)
self.assertEqual(sfs[0].id, self.sharedfile.id)
#but really, underneath we should have two favorites
fs = Favorite.where('user_id = %s', new_user.id)
self.assertEqual(2, len(fs))
def test_favorite_page_with_favorite(self):
with self.client as client:
with client.session_transaction() as sess:
sess[KEY]=999
new_fav = Favorite(id=1, user_id=999, drink_id=1)
db.session.add(new_fav)
resp = client.get('/user/favorites')
self.assertIn('<div class="carousel-inner">', str(resp.data))
self.assertIn('<div class="card ', str(resp.data))
self.assertIn('<h5 class="card-title">A1</h5>', str(resp.data))
self.assertIn('<a href="/drinks/1"', str(resp.data))
self.assertIn('<table ', str(resp.data))
self.assertIn('<thead>', str(resp.data))
self.assertIn('<tr ', str(resp.data))
self.assertIn('id</th>', str(resp.data))
self.assertIn('Name</th>', str(resp.data))
self.assertIn('Ingredients</th>', str(resp.data))
self.assertIn('<tbody>', str(resp.data))
self.assertIn('<tr>', str(resp.data))
self.assertIn('1</th>', str(resp.data))
self.assertIn('<td>', str(resp.data))
self.assertIn('<a href="/drinks/1">A1</a>', str(resp.data))
self.assertIn('Recommend</button>', str(resp.data))
self.assertIn('Remove</button>', str(resp.data))
def add_planet(username):
"""Adds a planet to a user list and redirects to search results page"""
if not g.user or g.user.username != username:
flash("Unauthorized access.")
return redirect("/")
messages = []
list_id = request.json["list_id"]
planets = request.json["planets"]
user_list = List.query.get(list_id)
user = user_list.user
for planet in planets:
if Favorite.query.filter_by(list_id=list_id,
planet_name=planet).first() == None:
favorite = (Favorite(planet_name=planet, list_id=list_id))
db.session.add(favorite)
messages.append(f"{planet} added to {user_list.name}")
else:
messages.append(f"{planet} already exists in {user_list.name}")
db.session.commit()
resp = {"messages": messages}
return (jsonify(resp), 201)
def test_show_favorites(self):
"""Test favorite page."""
with app.test_client() as client:
with client.session_transaction() as session:
session["USER_ID"] = self.user_id
# Without favorites
res = client.get("/favorites")
html = res.get_data(as_text=True)
self.assertEqual(res.status_code, 200)
self.assertIn("You have <b>no</b> favorite songs.", html)
# With favorites
favorite = Favorite(user_id=self.user_id, song_key=SONG_JSON["key"])
song = Song(playlist_id=None, external_song_key=SONG_JSON["key"], song_title=SONG_JSON["title"], song_artist=SONG_JSON["subtitle"])
db.session.add_all((favorite, song))
db.session.commit()
res = client.get("/favorites")
html = res.get_data(as_text=True)
self.assertEqual(res.status_code, 200)
self.assertIn(SONG_JSON["title"], html)
def setUp(self):
"""Create test client, add sample data."""
User.query.delete()
List.query.delete()
Favorite.query.delete()
self.client = app.test_client()
user = User(username="******",
first_name="Test",
last_name="User",
email="*****@*****.**",
password="******")
db.session.add(user)
self.user = User.query.filter_by(username="******").first()
user_list = List(name="testplanets",
description="my testplanets",
user_id=self.user.id)
db.session.add(user_list)
self.list = List.query.filter_by(name="testplanets").first()
favorite = Favorite(list_id=self.list.id, planet_name="GJ 876 c")
db.session.add(favorite)
self.favorite = Favorite.query.filter_by(list_id=self.list.id).first()
db.session.commit()
def favorite_recipe(recipe_id):
"""Add or remove favorite recipe"""
if not g.user:
flash("Login/Signup To Save Recipes.", "danger")
return redirect(f"/recipe/{recipe_id}")
user = User.query.get_or_404(g.user.id)
recipe = Recipe.query.get_or_404(recipe_id)
fav_recipes = Favorite.query.filter_by(user_id=user.id).all()
# check to see if recipe in favorite recipes already. If already a favorite, remove from favorite recipes. If not, add to favorite recipes.
fav_recipe_ids = [fav_recipe.recipe_id for fav_recipe in fav_recipes]
if recipe.id in fav_recipe_ids: # If this recipe id is already in current user's favorites, delete it
for fav in fav_recipes: # loop through user's favorite recipes
if recipe.id == fav.recipe_id: # when it gets to the recipe we are trying to delete
f = Favorite.query.get(
fav.id
) # get the Favorite object that relates this user this recipe by the Favorite's id
db.session.delete(f)
db.session.commit()
else:
pass
flash(f"Removed {recipe.title} from favorites", "danger")
return redirect(f"/recipe/{recipe.id}")
else:
g.user.recipes.append(Favorite(user_id=user.id, recipe_id=recipe_id))
db.session.commit()
flash(f"Added {recipe.title} to favorites", "success")
return redirect(f"/recipe/{recipe.id}")
def favorites(user_id=None):
if request.method == 'GET':
if user_id is not None:
users = User.query.all()
if user_id > len(users):
return jsonify({ "fail": "user does not exist" }), 404
user = User.query.get(user_id)
if not user.favorites:
return jsonify({ "fail": "user does not have favorites" }), 404
return jsonify({
"success": "Favorites found",
"favorites": user.favorites.serialize()
}),200
else:
users= User.query.all()
users = list(
map(lambda user_favs: user.serialize(), users)
)
if request.method == 'POST':
id_vehicle = request.json.get('id_vehicle',)
id_character = request.json.get('id_character')
id_planet = request.json.get('id_planet')
user = User.query.filter_by(id = user_id).first()
if not user:
return jsonify({"fail": "the indicated user does not exist"})
vehicle = Vehicle.query.filter_by(id= id_vehicle).first()
character = Character.query.filter_by(id=id_character).first()
planet = Planet.query.filter_by(id=id_planet).first()
favorite = Favorite()
user.favorites = favorite
favorite.vehicles.append(vehicle)
favorite.characters.append(character)
favorite.planets.append(planet)
favorite.save()
user.update()
return jsonify({
"success": "favorites added",
"favorites": favorite.serialize()
})
def test_add_favorite(self):
"""
A user should be able to favorite a sharedfile if:
- it belongs to another user
- it's not already favorited
- if it's been favorited, but favorite was "deleted"
A user shouldn't be able to favorite a sharedfile if they own it.
"""
# Create new user with their own sharedfile.
new_user = User(name='newuser',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, is_paid=1)
new_user.save()
new_sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file", \
user_id=new_user.id, content_type="image/png", share_key="ok")
new_sharedfile.save()
# One should be able to favorite another user's sharedfile
self.assertTrue(self.user.add_favorite(new_sharedfile))
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
self.assertEqual(1, len(favorites))
# Can't favorite an already favorited sharedfile.
self.assertFalse(self.user.add_favorite(new_sharedfile))
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
self.assertEqual(1, len(favorites))
# A favorite with "deleted" flag set, should have flag unset and
# return True when add_favorite called
favorite = Favorite.get("user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
favorite.deleted = True
favorite.save()
self.assertTrue(self.user.add_favorite(new_sharedfile))
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
self.assertEqual(1, len(favorites))
# Can't favorite one's own sharedfile.
self.assertTrue(self.sharedfile.user_id, self.user.id)
self.assertFalse(self.user.add_favorite(self.sharedfile))
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, self.sharedfile.id)
self.assertEqual(0, len(favorites))
def test_post_favorites2__fail(self):
user = add_user(USER1, PASS1)
data = {"data": {"type": "favorite", "attributes": {"item_uuid": ""}}}
resp = open_with_auth(self.app, API_ENDPOINT.format('favorites/'),
'POST', user.email, PASS1, 'application/json',
json.dumps(data))
assert resp.status_code == BAD_REQUEST
assert Favorite.select().count() == 0
def favorite_applicant(request, event_name, name):
try:
applicant = Applicant.objects.get(norm_name=normalize_name(name), event__name=event_name)
except Applicant.DoesNotExist:
raise Http404('Applicant does not exist.')
if request.method == 'POST':
try:
fav = Favorite.objects.get(applicant=applicant, scholar=request.user.mcuser)
fav.delete()
return JsonResponse({'msg': 'unstarred'})
except Favorite.DoesNotExist:
favs = Favorite.objects.filter(scholar=request.user.mcuser, applicant__event__name=event_name)
if favs.count() < 5:
fav = Favorite(applicant=applicant, scholar=request.user.mcuser)
fav.save()
return JsonResponse({'msg': 'starred'})
return JsonResponse({'msg': 'max stars given'})
return HttpResponse('Please POST')
def test_add_remove_fav(self):
new_fav = Favorite(user_id=11111, drink_id=1)
new_fav.id = 10000
db.session.add(new_fav)
fav = Favorite.query.get(10000)
self.assertEqual(fav.id, 10000)
self.assertEqual(fav.user_id, 11111)
self.assertEqual(fav.drink_id, 1)
db.session.delete(fav)
db.session.commit()
check_fav = Favorite.query.get(10000)
self.assertEqual(check_fav, None)
def test_favorite_keys(self):
"""Test that user's favorite song keys are returned"""
favorite = Favorite(user_id=self.user_id, song_key=SONG_JSON["key"])
db.session.add(favorite)
db.session.commit()
self.assertIn(int(SONG_JSON['key']), self.user.favorites_keys())
def set_tweet_as_favorite(user, id_):
try:
check_tweet_existence(id_)
new_fav = Favorite(user_id=user['id'], tweet_id=id_)
db.session.add(new_fav)
db.session.commit()
return jsonify(success=True), 201
except Exception as e:
return str(e)
def create_favorite():
current_user = get_jwt_identity()
body = request.get_json()
new_favorite = Favorite(item_id=new_favorite["item_id"], item_type=new_favorite["item_type"], user_id=new_favorite["user_id"])
db.session.add(new_favorite)
db.session.commit()
return jsonify({"new favorite": body}), 200
def drops_all_tables(database):
"""Doesn't drop unknown tables."""
tables = database.get_tables()
for table in tables:
if table == 'item':
Item.drop_table()
if table == 'order':
Order.drop_table()
if table == 'user':
User.drop_table()
if table == 'orderitem':
OrderItem.drop_table()
if table == 'address':
Address.drop_table()
if table == 'picture':
Picture.drop_table()
if table == 'favorite':
Favorite.drop_table()
def create_favorite():
body = request.get_json()
new_favorite = Favorite(name=body["name"], category=body["category"], user_id=body["user_id"])
db.session.add(new_favorite)
db.session.commit()
favorites = Favorite.query.all()
all_favorites = list(map(lambda x: x.serialize(), favorites))
return jsonify(all_favorites), 200
def show_favorite(self):
###############################
# SHOW Favorite #
###############################
# Show user's Favorite product and substitute
self.get_data(Favorite())
self.choosing_option()
def get_favorite(id):
from models import Favorite, Item
favorite_items = []
obj = Favorite.objects(user_id=id)
if obj:
favorite = obj.get()
for article_id in favorite.article_list:
item = Item.objects(artical_id=article_id).get()
favorite_items.append(item)
return dumps(convert_items_to_list(favorite_items))
def del_favorite(user_id, article_id):
from models import Favorite
obj = Favorite.objects(user_id=user_id)
if obj:
favorite = obj.get()
if article_id in favorite.article_list:
obj.update_one(pull__article_list=article_id)
return jsonify({"response_msg": "success",
"response_code": 200}), 200
return jsonify({"response_msg": "Not Found", "response_code": 404}), 404
def favorite_action(request,vidnum):
try:
venue = Venue.objects.get(id=vidnum)
old_favorite = get_or_none(Favorite,venue=venue, user=request.user)
status = 0
if old_favorite:
old_favorite.delete()
status = 0
else:
fav = Favorite()
fav.user = request.user
fav.venue = venue
fav.save()
status = 1
return HttpResponse(json.dumps({"is_fav": status}) ,content_type="applcation/json")
except Exception, e:
print e
res = HttpResponse()
res.status_code = 404
return res
def favorite_for_company(self, request):
user = endpoints.get_current_user()
query = Favorite.query(ancestor=main.get_parent_key(user)).filter(Favorite.company_entity_key == request.company_entity_key)
returnFavorite = Favorite(message="null")
for favorite in query:
returnFavorite = favorite
break
return returnFavorite
def company_list_favorite(self, query):
# list of companies with favorite boolean attached to favorites
user = endpoints.get_current_user()
for company in query:
company.favorite = False
key = ndb.Key(urlsafe=company.entityKey)
favQuery = Favorite.query(ancestor=main.get_parent_key(user)).filter(Favorite.company_entity_key == key)
for favorite in favQuery:
company.favorite = True
return query
def article_with_user(article_id):
if not request.json:
abort(400)
if not 'user_id' in request.json:
abort(400)
user_id = request.json['user_id']
from models import Artical, Favorite
article = Artical.objects(artical_id=article_id).get()
obj = Favorite.objects(user_id=user_id)
if obj:
favorite = obj.get()
article_list = favorite.article_list
if article_id in article_list:
return dumps(convert_artical_to_dict(article, True))
return dumps(convert_artical_to_dict(article, False))
def company_insert_favorite(self, request):
user = endpoints.get_current_user()
favBool = request.favorite
key = ndb.Key(urlsafe=request.entityKey)
query_favorite = Favorite.query(ancestor=main.get_parent_key(user)).filter(Favorite.company_entity_key == key)
my_favorite = Favorite(parent=main.get_parent_key(user), company_entity_key=key)
found = False
logging.info(favBool)
for item in query_favorite:
logging.info("favorite logged")
my_favorite = item
found = True
logging.info(my_favorite)
if favBool:
logging.info("favorite bool = True")
if not found:
logging.info("creating favorite")
# my_favorite = Favorite(parent=main.get_parent_key(user), company_entity_key=key)
my_favorite.put()
else:
if found:
logging.info("delete")
my_favorite.key.delete()
return request
def favorites(request):
"""
Method which handles favorites request
"""
if request.GET:
g = request.GET
action = g.get('a', None)
fromS = g.get('fromS', None)
viaS = g.get('viaS', None)
ftype = g.get('type', DEPARTURES)
# Check if we are trying to delete an existing favorite
if action == 'd':
id = g.get('id', None)
if not id:
return _redirect_home_with_msg(request, "ID missing. Cannot delete favorite.")
try:
fav = Favorite.objects.get(id=id, user=request.user)
fav.delete()
return _redirect_home_with_msg(request, "Favorite removed successfully.")
except Favorite.DoesNotExist:
return _redirect_home_with_msg(request, "Invalid favorite id.")
if not fromS:
return _redirect_home_with_msg(request, "location missing. cannot save favorite!")
crslist = _getCRS(fromS)
filterCrslist = _getCRS(viaS)
if not crslist:
return _redirect_home_with_msg(request, "Invalid station name")
if len(crslist) > 1 or (filterCrslist and len(filterCrslist) > 1):
return _redirect_home_with_msg(request, "Multiple station names retrieved.")
fsn, crs = crslist[0]
vsn = filterCrs = None
if filterCrslist:
vsn, filterCrs = filterCrslist[0]
# Construct a good favorite name
fname = fsn + ' ' + ftype
desc = ''
if vsn:
desc = 'Via ' + vsn
# See if the user is logged in.
loggedIn = _checkLoggedIn(request)
return render_to_response('fav.html', {'fname' : fname,
'fromS' : fromS,
'viaS' : viaS,
'ftype' : ftype,
'desc' : desc,
'loggedIn' : loggedIn,
},
context_instance=RequestContext(request))
if request.POST:
p = request.POST
fromS = p.get('fromS', None)
viaS = p.get('viaS', None)
ftype = p.get('type', 'Departures')
fname = p.get('fname', None)
desc = p.get('desc', '')
if not fname or not fromS:
return _redirect_home_with_msg(request, "Missing values. Favorite not saved.")
# Retrieve or create the user.
username = p.get('username', None)
password = p.get('password', None)
loggedIn = _checkLoggedIn(request)
if not loggedIn:
if not username or not password or username.strip() == '' or password.strip() == '':
return _redirect_home_with_msg(request, "Cannot save favorite without registering.")
user = None
if getattr(request, 'user'):
user = request.user
if not user or user.is_anonymous():
try:
user = User.objects.get(username=username, password=password)
except User.DoesNotExist:
# Create the user and login
user = create_user(request, username, password)
user = authenticate(username=username, password=password)
login(request, user)
# Go ahead and save the favorite
fav = Favorite(user=user, fname=fname, desc=desc,
ftype=ftype, fromS=fromS, viaS=viaS)
fav.save()
return _redirect_home_with_msg(request, "Favorite saved.")
