def test_get_all_dishes(self): """ Test if all dishes from a restaurant is retrieved correctly """ response = self.client.get('/api/dish/approved/' + str(self.restaurant._id) + '/') dishes = [ model_to_json(Food.objects.get(_id=str(self.dish_1._id))), model_to_json(Food.objects.get(_id=str(self.dish_2._id))) ] expected = {'Dishes': dishes} self.assertDictEqual(expected, json.loads(response.content))
def test_get_post(self): """ Test if restaurant posts are retrieved correctly """ response = self.client.get('/api/restaurant/post/') actual = json.loads(response.content) for post in actual['Posts']: post.pop('Timestamp') posts = [ model_to_json( RestaurantPost.objects.get(_id=str(self.post_1._id))), model_to_json(RestaurantPost.objects.get(_id=str(self.post_2._id))) ] expected = {"Posts": posts} self.assertDictEqual(expected, actual)
def delete(self, request, post_id): """ Deletes a single restaurant post """ user = request.user check_user_status(user) post_deleted = RestaurantPost.remove_post(post_id) return JsonResponse({"Deleted post": model_to_json(post_deleted)})
def post(self, request): """ insert a newsletter user into the db provided all the user fields """ validate(instance=request.data, schema=schemas.newsletter_signup_schema) body = request.data ip = get_client_ip_address(request) block = NLAudit.update_audit(ip) if block: msg = "You have submitted too many signups and have been temporarily blocked. Please do not spam our system!" return JsonResponse( { 'status': 500, 'code': 'too_many_signups', 'detail': msg }, status=500) NLUser.field_validate(body) user = NLUser.signup(first_name=body['first_name'], last_name=body['last_name'], email=body['email'], consent_status=body['consent_status'], expired_at=date.today() + relativedelta(days=+182)) return JsonResponse(model_to_json(user))
def test_get_dishes(self): """ Tests if dishes for restaurant owned by user are retrieved correctly """ response = self.client.get('/api/dish/pending/') dishes = [ model_to_json(PendingFood.objects.get(_id=str(self.dish_2._id))) ] expected = {'Dishes': dishes} self.assertDictEqual(expected, json.loads(response.content))
def insert_tag_page(request): """Insert tag to database""" validate(instance=request.body, schema=tag_schema) body = json.loads(request.body) food_name, restaurant_id, category, value = \ body['food_name'], body['restaurant_id'], body['category'], body['value'] tag = ManualTag.add_tag(food_name, restaurant_id, category, value) return JsonResponse(model_to_json(tag))
def test_get_favs(self): """ Tests if all favourited restaurants are retrieved correctly """ response = self.client.get('/api/user/favourite/') actual = json.loads(response.content) fav_rest = Restaurant.objects.get(_id=str(self.restaurant_2._id)) fav_rest.offer_options = ast.literal_eval(fav_rest.offer_options) expected = [model_to_json(fav_rest)] self.assertListEqual(expected, actual)
def get(self, request): """ Retrieves a restaurant owner profile """ user = request.user check_user_status(user) user_id = user.id restaurant_owner = RestaurantOwner.get_by_user_id(user_id=user_id) return JsonResponse(model_to_json(restaurant_owner))
def get_restaurant_page(request): """retrieve restaurant by id""" _id = request.GET.get('_id') restaurant = Restaurant.get(_id) if restaurant: return JsonResponse(model_to_json(restaurant)) else: return JsonResponse({})
def insert_dish_page(request): """Insert dish into database""" validate(instance=request.body, schema=food_schema) body = json.loads(request.body) invalid = Food.field_validate(body) if invalid: return JsonResponse(invalid) food = Food.add_dish(body) return JsonResponse(model_to_json(food))
def delete(self, request, dish_id): """ Deletes dish from database """ user = request.user check_user_status(user) user_id = user.id restaurant = PendingRestaurant.get_by_owner(user_id) deleted_dish = PendingFood.remove_dish(dish_id, restaurant._id) return JsonResponse(model_to_json(deleted_dish))
def get_all_posts_page(request): """ retrieve list of restaurants from database """ posts = list(TimelinePost.objects.all()) posts = sort(posts) response = {'Posts': []} for post in posts: time_stamp = {'Timestamp': post.Timestamp.strftime("%b %d, %Y %H:%M")} response['Posts'].append(model_to_json(post, time_stamp)) return JsonResponse(response)
def decline_cart_page(request): """Decline a cart which has been sent by a user""" validate(instance=request.body, schema=cart_schema) body = json.loads(request.body) try: cart = Cart().decline_cart(cart_id=body['_id']) return JsonResponse(model_to_json(cart)) except ValueError as error: return HttpResponseBadRequest(str(error))
def approve_food(model_admin, request, queryset): """ Approve of PendingFood record and insert it into Food collection, or updates the existing record in Food collection that corresponds to this PendingFood record. Sends a notification email to the restaurant email for each successful approval. """ count = 0 total = 0 wrong_status = False for f in queryset: total += 1 food = Food(**model_to_json(f)) old_food = Food.objects.filter(_id=f._id).first() restaurant = PendingRestaurant.objects.filter(_id=f.restaurant_id) if restaurant.exists() and f.status == Status.Pending.name: count += 1 restr = restaurant.first() owner_prefer_names = restr.owner_preferred_name food_name = f.name email = restr.email send_approval_email(owner_prefer_names, email, food_name, 'food') # If there's already an approved food record in Food collection # check if the food's picture is oudated, by comparing the url # to the url in the PendingFood's picture field. If they don't match # delete the approved food record's picture from google cloud bucket if old_food: if old_food.picture != f.picture: delete(old_food.picture) food.status = Status.Approved.name save_and_clean(food) else: wrong_status = True if count > 1: messages.success( request, "Successfully approved " + str(count) + " food profiles.") queryset.update(status=Status.Approved.name) elif count == 1: link = reverse("admin:restaurant_pendingfood_change", args=[f._id]) msg = format_html( "Successfully approved restaurant profile for <a href='{}' target='_blank' rel='noopener'>{}</a>", link, f.name) messages.success(request, msg) queryset.update(status=Status.Approved.name) elif wrong_status: messages.success( request, "The restaurant this dish belongs to does not exist, or the dish status if not 'Pending'" ) else: if total > 1: msg = "The selected food profiles have been approved already." else: msg = "The selected food profile has been approved already." messages.error(request, msg)
def test_get_pending_restaurant(self): """ Test if pending restaurant owned by ro is retrieved properly """ response = self.client.get('/api/restaurant/pending/') restaurant = PendingRestaurant.objects.get(owner_user_id=self.ro.id) restaurant.restaurant_image_url = ['/'] restaurant.payment_methods = ['/'] restaurant.offer_options = [''] expected = model_to_json(restaurant) self.assertDictEqual(expected, json.loads(response.content))
def get_post_by_restaurant_page(request): """Retrieve all posts from a restaurant""" rest_id = request.GET.get('restaurant_id') posts = list(TimelinePost.objects.filter(restaurant_id=rest_id)) posts = sort(posts) response = {'Posts': []} for post in posts: time_stamp = {'Timestamp': post.Timestamp.strftime("%b %d, %Y %H:%M")} response['Posts'].append(model_to_json(post, time_stamp)) return JsonResponse(response)
def get(self, request): """ Retrieve restaurant from pending collection by the owner's user_id """ user = request.user check_user_status(user) user_id = user.id restaurant = PendingRestaurant.get_by_owner(user_id) restaurant = model_to_json(restaurant) return JsonResponse(restaurant)
def put(self, request): """ Modifies a SubscriberProfile record in the database """ body = request.data user = request.user check_user_status(user) body['user_id'] = user.id SubscriberProfile.field_validate(body) profile = SubscriberProfile.edit(body) return JsonResponse(model_to_json(profile))
def update_status_page(request): """ Update cart status in database """ validate(instance=request.body, schema=status_schema) body = json.loads(request.body) if valid_status(body['status']): try: cart = getattr(Cart, OrderStates[body['status']].value)(Cart, body['_id']) return JsonResponse(model_to_json(cart)) except ValueError as error: return HttpResponseBadRequest(str(error)) return HttpResponseBadRequest('Invalid request, please check your request')
def edit_item_amount_page(request): """ Edit food item """ validate(instance=request.body, schema=item_schema) body = json.loads(request.body) responsemessage = Item.edit_item_amount(body['item_id'], body['count']) for entry in responsemessage: try: responsemessage[entry] = model_to_json(responsemessage[entry]) except AttributeError: pass return JsonResponse(responsemessage)
def post(self, request): """ Insert new restaurant as a draft into database """ user = request.user check_user_status(user) validate(instance=request.data, schema=schemas.restaurant_insert_draft_schema) body = request.data PendingRestaurant.field_validate_draft(body) restaurant = PendingRestaurant.insert(body) return JsonResponse(model_to_json(restaurant))
def put(self, request): """ Updates a restaurant owner profile """ user = request.user check_user_status(user) user_id = user.id validate(instance=request.data, schema=schemas.restaurant_owner_edit_schema) body = request.data RestaurantOwner.field_validate(body) profile = RestaurantOwner.edit_profile(user_id, body) return JsonResponse(model_to_json(profile))
def insert_restaurant_page(request): """Insert new restaurant into database""" validate(instance=request.body, schema=restaurant_schema) body = json.loads(request.body) invalid = Restaurant.field_validate(body) if invalid: return JsonResponse(invalid) try: restaurant = Restaurant.insert(body) return JsonResponse(model_to_json(restaurant)) except ValueError: return HttpResponseBadRequest('duplicate email')
def put(self, request): """ Edit a restaurant profile and save it as a draft in the database """ user = request.user check_user_status(user) user_id = user.id validate(instance=request.data, schema=schemas.restaurant_edit_draft_schema) body = request.data PendingRestaurant.field_validate_draft(body) restaurant = PendingRestaurant.edit_draft(user_id, body) return JsonResponse(model_to_json(restaurant))
def get(self, request, format_type): """ Retrieves analytics data for all restaurants page given their restaurant ids and format of date """ restaurants = list(Restaurant.objects.all()) restaurant_data = {} for restaurant in restaurants: restJson = model_to_json(restaurant) rest_id = restJson.get('_id') traffic = get_analytics_data(rest_id, format_type) traffic['name'] = restJson.get('name') restaurant_data[rest_id] = traffic return JsonResponse(restaurant_data)
def put(self, request): """ For updating existing image caption for a restaurant """ user = request.user check_user_status(user) user_id = user.id body = request.data validate(instance=body, schema=schemas.image_captions_schema) restaurant = PendingRestaurant.get_by_owner(user_id) restaurant = PendingRestaurant.update_image_captions(restaurant, body) return JsonResponse(model_to_json(restaurant))
def test_get_approved_restaurant(self): """ Test if approved restaurant is retrieved by _id """ _id = Restaurant.objects.get(email="*****@*****.**")._id response = self.client.get('/api/restaurant/approved/' + str(_id) + '/') restaurant = Restaurant.objects.get(email="*****@*****.**") restaurant.restaurant_image_url = ['/'] restaurant.payment_methods = ['/'] restaurant.offer_options = [''] expected = model_to_json(restaurant) self.assertDictEqual(expected, json.loads(response.content))
def upload_post_page(request): """Upload post into post timeline post table""" try: # validate request validate(instance=request.body, schema=post_schema) except jsonschema.exceptions.ValidationError: return HttpResponseBadRequest('Invalid request') body = json.loads(request.body) post = TimelinePost(**body) post.full_clean() post.save() return JsonResponse(model_to_json(post, {'Timestamp': post.Timestamp}))
def edit_restaurant_page(request): """Update restaurant data""" validate(instance=request.body, schema=restaurant_schema) body = json.loads(request.body) invalid = Restaurant.field_validate(body) if invalid: # exit if invalid body return JsonResponse(invalid) restaurant = Restaurant.get(body["restaurant_id"]) edit_model(restaurant, body, restaurant_editable) if address_changed(body): update_model_geo(restaurant, body['address']) restaurant = save_and_clean(restaurant) return JsonResponse(model_to_json(restaurant))
def post(self, request): """ Insert a new post for a restaurant """ user = request.user check_user_status(user) user_id = user.id validate(instance=request.data, schema=schemas.post_schema) body = request.data body['owner_user_id'] = user_id RestaurantPost.field_validate(body) post = RestaurantPost.insert(body, request) return JsonResponse(model_to_json(post))