def __handle_listing_get(request, listing_id):
if listing_id == 'all':
result = __filter(Listing.objects.all(), request.GET)
if len(result) == 0:
return generate_response("no queries matched filters",
True,
payload={"result": []})
else:
return generate_response("found results",
True,
obj_list=list(result))
else:
try:
listing = Listing.objects.get(pk=listing_id)
recs_exist = Recommendation.objects.filter(
item=listing_id).exists()
if recs_exist:
recs = Recommendation.objects.get(
item=listing_id).recommended_items
recs = list(map(int, recs.split(',')))
rec_listings = Listing.objects.filter(pk__in=recs)
rec_list = []
for i in rec_listings:
rec_list.append(serialize(i))
res = {}
res["success"] = True
res["msg"] = 'listing found'
res["result"] = serialize(listing)
if recs_exist:
res['recs'] = rec_list
return JsonResponse(res)
except:
return generate_response("listing not found", False)
def delete_review(request, review_id):
try:
review = Review.objects.get(pk=review_id)
review.delete()
return generate_response("review deleted", True, review)
except:
return generate_response("review does not exist", False)
def delete_listing(request, listing_id):
try:
listing = Listing.objects.get(pk=listing_id)
listing.delete()
return generate_response("listing deleted", True, listing)
except:
return generate_response("listing does not exist", False)
def delete_book(request, book_id):
try:
book = Book.objects.get(pk=book_id)
book.delete()
return generate_response("book deleted", True, book)
except:
return generate_response("book does not exist", False)
def __handle_create_user_post(request):
"""
Creates a new user with a hashed password. Success is false if the username already exists.
"""
try:
username = request.POST['username']
if not User.objects.filter(username = username).exists():
password = hashers.make_password(request.POST['password'])
first_name = request.POST['first_name']
last_name = request.POST['last_name']
user = User(
username = username,
password = password,
first_name = first_name,
last_name = last_name
)
user.save()
return generate_response("user created", True, user)
else:
return generate_response("username already exists", False)
except KeyError as e:
return generate_response("missing %s" % e.args[0].strip("'"), False)
except Exception as e:
return generate_response(str(e), False)
def delete_user(request, user_id):
"""
Delete user with the specified primary key
"""
try:
user = User.objects.get(pk=user_id)
user.delete()
return generate_response("user deleted", True, user)
except:
return generate_response("user not found", False)
def delete_author(request, author_id):
"""
Delete author with the specified primary key
"""
try:
author = Author.objects.get(pk=author_id)
author.delete()
return generate_response("author deleted", True, author)
except:
return generate_response("author not found", False)
def __handle_create_authenticator_post(request):
try:
user_id = request.POST['user_id']
authenticator = __get_random_authenticator(user_id)
authenticator.save()
return generate_response("authenticator generated",
True,
obj=authenticator)
except Exception as e:
return generate_response(str(e), False)
def __handle_authenticate_user_post(request):
try:
username = request.POST['username']
password = request.POST['password']
result = User.objects.get(username = username)
correct_password = hashers.check_password(password, result.password)
if correct_password:
return generate_response("user authenticated", True, result)
else:
return generate_response("incorrect username or password", False)
except Exception as e:
return generate_response(str(e), False)
def __handle_user_get(request, user_id):
if user_id == 'all':
result = __filter(User.objects.all(), request.GET)
if len(result) == 0:
return generate_response("no queries matched filters", True, payload = {"result": []})
else:
return generate_response("found results", True, obj_list = list(result))
else:
try:
user = User.objects.get(pk=user_id)
return generate_response("user found", True, user)
except:
return generate_response("user not found", False)
def __handle_author_get(request, author_id):
if author_id == 'all':
result = __filter(Author.objects.all(), request.GET)
if len(result) == 0:
return generate_response("no queries matched filters", True, payload = {"result": []})
else:
return generate_response("found results", True, obj_list = list(result))
else:
try:
author = Author.objects.get(pk=author_id)
return generate_response("author found", True, author)
except:
return generate_response("author not found", False)
def __handle_author_post(request, author_id):
"""
For updating author
"""
try:
author = Author.objects.get(pk = author_id)
for key in request.POST:
value = request.POST[key]
if key == 'first_name': author.first_name = value
elif key == 'last_name': author.last_name = value
elif key == 'age': author.age = value
author.save()
return generate_response("author updated", True, author)
except:
return generate_response("author not found", False)
def __handle_user_post(request, user_id):
"""
For updating a user. Users cannot change their username.
"""
try:
user = User.objects.get(pk = user_id)
for key in request.POST:
value = request.POST[key]
if key == 'first_name': user.first_name = value
elif key == 'last_name': user.last_name = value
elif key == 'password': user.password = hashers.make_password(value)
user.save()
return generate_response("user updated", True, user)
except:
return generate_response("user not found", False)
def __handle_create_author_post(request):
try:
first_name = request.POST['first_name']
last_name = request.POST['last_name']
age = request.POST['age']
author = Author(
first_name = first_name,
last_name = last_name,
age = age
)
author.save()
return generate_response("author created", True, author)
except KeyError as e:
return generate_response("missing %s" % e.args[0].strip("'"), False)
except Exception as e:
return generate_response(str(e), False)
def create_listing(request):
"""
Handles the /listing/create endpoint for creating a listing and adding it to the database.
"""
if request.method == 'POST':
return __handle_create_listing_post(request)
return generate_response("Only POST requests allowed", False)
def authenticate_user(request):
"""
Authenticates a user using their plaintext password and returns success: True if authenticated successfully.
"""
if request.method == 'POST':
return __handle_authenticate_user_post(request)
return generate_response("only POST requests are allowed", False)
def __handle_book_get(request, book_id):
if book_id == 'all':
result = __filter(Book.objects.all(), request.GET)
if len(result) == 0:
return generate_response("no queries matched filters",
True,
payload={"result": []})
else:
return generate_response("found results",
True,
obj_list=list(result))
else:
try:
book = Book.objects.get(pk=book_id)
return generate_response("book found", True, book)
except:
return generate_response("book not found", False)
def __handle_listing_get(request, listing_id):
if listing_id == 'all':
result = __filter(Listing.objects.all(), request.GET)
if len(result) == 0:
return generate_response("no queries matched filters",
True,
payload={"result": []})
else:
return generate_response("found results",
True,
obj_list=list(result))
else:
try:
listing = Listing.objects.get(pk=listing_id)
return generate_response("listing found", True, listing)
except:
return generate_response("listing not found", False)
def __handle_review_get(request, review_id):
if review_id == 'all':
result = __filter(Review.objects.all(), request.GET)
if len(result) == 0:
return generate_response("no queries matched filters",
True,
payload={"result": []})
else:
return generate_response("found results",
True,
obj_list=list(result))
else:
try:
review = Review.objects.get(pk=review_id)
return generate_response("review found", True, review)
except:
return generate_response("review not found", False)
def create_user(request):
"""
Handles the /user/create endpoint for creating an user and adding it to the database.
"""
if request.method == 'POST':
return __handle_create_user_post(request)
else:
return generate_response("only POST requests are allowed", False)
def create_author(request):
"""
Handles the /author/create endpoint for creating an author and adding it to the database.
This currently accepts the preferred method of key-value form data as stated in the
Project 2 description.
"""
if request.method == 'POST':
return __handle_create_author_post(request)
return generate_response("only POST requests are allowed", False)
def __handle_book_post(request, book_id):
try:
book = Book.objects.get(pk=book_id)
for key in request.POST:
value = request.POST[key]
if key == 'title':
book.title = value
elif key == 'year_published':
book.year_published = value
elif key == 'rating':
book.rating = value
elif key == 'author':
author = Author.objects.get(pk=value)
book.author = author
book.save()
return generate_response("book updated", True, book)
except:
return generate_response("error while updating book", False)
def create_authenticator(request):
"""
Handles the /authenticator/create endpoint for creating an authenticator and adding it to the database.
Must POST the user_id to associate with the authenticator
"""
if request.method == 'POST':
return __handle_create_authenticator_post(request)
return generate_response(
"create_authenticator: only POST requests are allowed", False)
def authenticator(request, authenticator_id):
"""
Lookup an authenticator with its pk.
return success True if found, else False
"""
if request.method == 'GET':
return __handle_authenticator_get(request, authenticator_id)
return generate_response("authenticator: only GET requests are allowed",
False)
def __handle_create_listing_post(request):
try:
user_id = request.POST['lister']
lister = User.objects.get(pk=user_id)
book_id = request.POST['book']
book = Book.objects.get(pk=book_id)
price = request.POST['price']
listing = Listing(
lister=lister,
book=book,
price=price,
book_title=book.title,
)
listing.save()
return generate_response("listing saved", True, listing)
except KeyError as e:
return generate_response("missing %s" % e.args[0].strip("'"), False)
except Exception as e:
return generate_response(str(e), False)
def __handle_create_book_post(request):
try:
title = request.POST['title']
year_published = request.POST['year_published']
rating = request.POST['rating']
author_id = request.POST['author']
author = Author.objects.get(pk=author_id)
book = Book(
title=title,
year_published=year_published,
rating=rating,
author=author,
)
book.save()
return generate_response("book saved", True, book)
except KeyError as e:
return generate_response("missing %s" % e.args[0].strip("'"), False)
except Exception as e:
return generate_response(str(e), False)
def __handle_listing_post(request, listing_id):
try:
listing = Listing.objects.get(pk=listing_id)
for key in request.POST:
value = request.POST[key]
if key == 'lister':
user = User.objects.get(pk=value)
listing.lister = user
elif key == 'post_date':
listing.post_date = value
elif key == 'book':
book = Book.objects.get(pk=value)
listing.book = book
listing.book_title = book.title
elif key == 'price':
listing.price = value
listing.save()
return generate_response("listing updated", True, listing)
except:
return generate_response("listing not found", False)
def __handle_create_review_post(request):
try:
user_id = request.POST['reviewer']
reviewer = User.objects.get(pk=user_id)
book_id = request.POST['book']
book = Book.objects.get(pk=book_id)
rating = request.POST['rating']
content = request.POST['content']
review = Review(
reviewer=reviewer,
book=book,
rating=rating,
content=content,
)
review.save()
return generate_response("review saved", True, review)
except KeyError as e:
return generate_response("missing %s" % e.args[0].strip("'"), False)
except Exception as e:
return generate_response(str(e), False)
def __handle_review_post(request, review_id):
try:
review = Review.objects.get(pk=review_id)
for key in request.POST:
value = request.POST[key]
if key == 'reviewer':
user = User.objects.get(pk=value)
review.reviewer = user
elif key == 'pub_date':
review.pub_date = value
elif key == 'book':
book = Book.objects.get(pk=value)
review.book = book
elif key == 'rating':
review.rating = value
elif key == 'content':
review.content = value
review.save()
return generate_response("review updated", True, review)
except:
return generate_response("review not found", False)
