def new(request):
review = Review()
if request.method == 'POST':
title = request.POST['title']
description = request.POST['description']
author = request.user
name = slugify(title)
unique_name = name
i = 0
while Review.objects.filter(name=unique_name, author__username=request.user.username):
i = i + 1
unique_name = name + '-' + str(i)
review = Review(name = unique_name, title = title, description = description, author=author)
is_valid = True
if not title:
is_valid = False
messages.add_message(request, messages.ERROR, 'Title is a required field.')
elif len(title) > 250:
is_valid = False
messages.add_message(request, messages.ERROR, 'The title should not exceed 250 characters.')
if len(description) > 500:
is_valid = False
messages.add_message(request, messages.ERROR, 'The description should not exceed 500 characters.')
if is_valid:
review.save()
messages.add_message(request, messages.SUCCESS, 'Review created with success.')
return redirect('/' + review.author.username + '/' + review.name + '/')
context = RequestContext(request, {'review': review})
return render_to_response('reviews/new.html', context)
def test_review_replies(self):
"""
Make sure that developer replies are not returned as if they were
original reviews.
"""
addon = Addon.objects.get(id=3615)
u = UserProfile.objects.get(pk=2519)
version = addon.get_version()
new_review = Review(version=version,
user=u,
rating=2,
body='hello',
addon=addon)
new_review.save()
new_reply = Review(version=version,
user=u,
reply_to=new_review,
addon=addon,
body='my reply')
new_reply.save()
review_list = [r.pk for r in u.reviews]
eq_(len(review_list), 1)
assert new_review.pk in review_list, (
'Original review must show up in review list.')
assert new_reply.pk not in review_list, (
'Developer reply must not show up in review list.')
def test_ensure_ratings_are_valid(self):
upper = Review(rating=6)
upper.save()
self.assertEqual((upper.rating<=5),True)
lower = Review(rating=0)
lower.save()
self.assertEqual((lower.rating>0),True)
def test_can_create_a_review(self):
user = get_user_model().objects.create(username='******')
category = Category.objects.create(
title='category',
slug='catslug',
featured=False,
image='test.png',
)
product = Product.objects.create(
name='testproduct',
slug="testslug",
category=category,
image='image.png',
summary="summary",
description="description",
price=19.99,
)
review = Review(
user=user,
product=product,
title='test',
review='review',
rating=4.0,
)
review.save()
self.assertEqual(review.user, user)
self.assertEqual(review.product, product)
self.assertEqual(review.title, 'test')
self.assertEqual(review.review, 'review')
self.assertEqual(review.rating, 4.0)
def setup(self):
self.new_wine = Wine(name='Wine1')
self.new_review = Review(wine=self.new_wine,
pub_date=datetime(2015, 1, 1, 12, 30, 59, 0),
user_name='admin',
comment='Best wine',
rating=4)
def test_company_rating_two_point_five(self):
"""The company rating should be two point five"""
company = Company.objects.get(name="test_apple_test")
reviewer = Reviewer.objects.get(name="john")
client = Client.objects.get(username='******')
review = Review.objects.create(
rating=5,
title="review",
summary="review text",
ip="127.0.0.1",
company=company,
reviewer=reviewer,
client=client
)
review = Review(
rating=1,
title="review",
summary="review text",
ip="127.0.0.1",
company=company,
reviewer=reviewer,
client=client
)
review.save()
company.update_average_rating()
self.assertEqual(company.get_rating(), 3)
def save_review_from_row(review_row):
review = Review()
review.user_name = review_row[0]
review.comment = review_row[1]
review.rating = review_row[2]
review.movie_id = review_row[3]
review.save()
def add_review(request, wine_id):
wine = get_object_or_404(Wine, pk=wine_id)
form = ReviewForm(request.POST)
if form.is_valid():
rating = form.cleaned_data["rating"]
print(rating)
print(form.cleaned_data)
comment = form.cleaned_data["comments"]
user_name = request.user.username
review = Review()
review.wine = wine
review.user_name = user_name
review.rating = rating
review.comments = comment
review.pub_date = datetime.datetime.now()
review.save()
update_clusters()
# Always return an HttpResponseRedirect after successfully dealing
# with POST data. This prevents data from being posted twice if a
# user hits the Back button.
return HttpResponseRedirect(
reverse("reviews:wine_detail", args=(wine.id, )))
return render(request, "reviews/wine_detail.html", {
"wine": wine,
"form": form
})
def extract_review_from_row(review_row):
review = Review(id=review_row["id"],
author=review_row["username"],
item=Item.objects.get(id=review_row["item_id"]),
rating=review_row["rating"],
review=review_row["comment"],
pub_date=datetime.datetime.now())
review.save()
def save_review_from_row(sword_row):
if sword_row.note != 'missing':
review = Review()
review.comment = sword_row.note
review.author_id = randint(1, 4)
review.sword_id = sword_row.name
review.rating = randint(1, 5)
review.save()
def save_review_from_row(review_row):
review = Review()
review.id = review_row[0]
review.user_name = review_row[1]
review.repo = Repo.objects.get(id=review_row[2])
review.rating = review_row[3]
review.pub_date = datetime.datetime.now()
review.comment = review_row[4]
review.save()
def test_rating_min_validator1(self):
rev = Review(date=self.date,
review_content='test test1',
sender_email='*****@*****.**',
sender_user_name='test123',
rating=1,
id=0)
rev.save()
self.assertEqual(Review.objects.filter(rating=1).count(), 1)
def product_review(request, pk):
if request.method == 'POST':
if request.user.is_authenticated:
r = Review(user=request.user,
text=request.POST.get('description'),
product=Product.objects.get(id=pk),
rating=int(request.POST.get('mark')))
r.save()
return redirect('product_page', pk=pk)
def get_dummy_reviews(revision):
"""Return a dictionary of Review objects for."""
cache_key = 'dummy_reviews_{}'.format(revision.metadata.document_id)
dummy_reviews = cache.get(cache_key, None)
if dummy_reviews is None:
revisions = revision.__class__.objects \
.filter(metadata__document=revision.document) \
.filter(review_start_date=None) \
.select_related('leader', 'approver') \
.prefetch_related('reviewers')
dummy_reviews = {}
for revision in revisions:
revision_reviews = []
for reviewer in revision.reviewers.all():
revision_reviews.append(
Review(role='reviewer',
status=Review.STATUSES.void,
reviewer=reviewer,
document_id=revision.metadata.document_id))
if revision.leader:
revision_reviews.append(
Review(role='leader',
status=Review.STATUSES.void,
reviewer=revision.leader,
document_id=revision.metadata.document_id))
if revision.approver:
revision_reviews.append(
Review(role='approver',
status=Review.STATUSES.void,
reviewer=revision.approver,
document_id=revision.metadata.document_id))
dummy_reviews[revision.revision] = revision_reviews
cache.set(cache_key, dummy_reviews, 5)
return dummy_reviews
def save_review_from_row(review_row):
review = Review()
# review.id = review_row[0]
review.user_name = review_row[0]
# review.wine = Wine.objects.get(id=review_row[2])
# print(review.wine)
review.wine = review_row[1]
review.rating = review_row[3]
review.pub_date = datetime.datetime.now()
review.comment = review_row[2]
review.save()
def init_review(self, username, gamename):
user = User(username=username)
user.save()
game = Game(name=gamename, releaseDate=date.today())
game.save()
return Review(poster=user,
game=game,
review_text='test',
rating=1,
post_datetime=date.today(),
votes=1)
def test_review_class_rating_choices_returned_value():
new_review = Review()
RATING_CHOICES = (
(1, '1'),
(2, '2'),
(3, '3'),
(4, '4'),
(5, '5'),
)
new_review.return_rating_choices = MagicMock(return_value=RATING_CHOICES)
assert new_review.return_rating_choices() == RATING_CHOICES
def save_reviews(csvpath):
df = pd.read_csv(csvpath)
data = df.to_dict(orient='records')
updated_data = []
for item in data:
updated_item = {**item, 'game': Game.objects.get(id=item['game_id'])}
updated_item.pop('game_id')
updated_data.append(Review(**updated_item))
Review.objects.bulk_create(updated_data)
return len(updated_data)
def test_create_review(self):
Review.author = User(username='******')
review = Review(game_title='Breath Of The Wild',
author='Teddy',
platform='Switch',
review='Absolutely breath-taking game!',
score='9')
self.assertEqual(review.game_title, 'Breath Of The Wild')
self.assertEqual(review.author, 'Teddy')
self.assertEqual(review.platform, 'Switch')
self.assertEqual(review.review, 'Absolutely breath-taking game!')
self.assertEqual(review.score, '9')
def test_create_review(self):
service = Service(name="Test Service for review",
description="Test description service review",
price=29)
review = Review(service=service,
date=timezone.now(),
comments="test review",
rating=4)
self.assertEqual(review.service.name, "Test Service for review")
self.assertEqual(review.comments, "test review")
self.assertEqual(review.rating, 4)
self.assertFalse(review.approved)
def test_rating_min_validator(self):
rev = Review(date=self.date,
review_content='test test1',
sender_email='*****@*****.**',
sender_user_name='test123',
rating=0,
id=0)
try:
rev.full_clean()
except ValidationError as err:
self.assertEqual(
str(err),
"{'rating': ['Ensure this value is greater than or equal to 1.']}"
)
def post(self, request, pk):
url = f'/furniture/details/{self.get_object().id}/'
post_values = request.POST.copy()
form = ReviewForm(post_values)
if form.is_valid():
author = Profile.objects.get(user__pk=request.user.id)
post_values['furniture'] = self.get_object()
review = Review(content=post_values['content'],
score=post_values['score'],
furniture=self.get_object(),
author=author)
review.save()
return HttpResponseRedirect(url)
def init_comment(self, username, reviewername, gamename):
comment_user = User(username=username)
comment_user.save()
review_user = User(username=reviewername)
review_user.save()
game = Game(name=gamename, releaseDate=date.today())
game.save()
review = Review(poster=review_user,
game=game,
post_datetime=date.today())
review.save()
return Comment(poster=comment_user,
review=review,
comment_text='test',
post_datetime=date.today(),
votes=1)
def create_unpublished_review(stay_pk):
try:
target_stay = Stay.objects.get(pk=stay_pk)
unpub_review = Review(corresponding_stay=target_stay)
unpub_review.full_clean()
unpub_review.save()
result = {'success': True, 'stay': target_stay}
except ValidationError as e:
result = {
'success': False,
'error_source':
'reviews.utils.create_unpublished_review: Validation Failed.',
'error_details': e.message_dict,
}
return result
def save_review_from_row(review_row):
review = Review()
try:
review.id = Review.objects.last().pk + 1 #review_row[0]
except: #TypeError:
review.id = 1
user = User.objects.get(username='' + str(int(review_row[1])))
review.user_name = user
#review.user_name = User.objects.get(id=review_row[1])
review.movie = Movie.objects.get(id=review_row[2])
review.rating = review_row[3]
review.comment = review_row[4]
review.pub_date = datetime.datetime.now()
# review.pub_date = review_row[5].strip() if review_row[5].strip() else datetime.datetime.now()
print 'saving ' + review.id
review.save()
def create_view(request):
next = request.GET.get('next', '/')
msg = ''
if request.user.is_authenticated:
if request.method == "POST":
review = Review()
review.account = request.user
review.restaurant = Restaurant.objects.get(
pk=int(request.POST['restaurant']))
review.title = request.POST['title']
review.content = request.POST['review']
review.food = int(request.POST['food'])
review.price = int(request.POST['price'])
review.service = int(request.POST['service'])
review.environment = int(request.POST['environment'])
result = sum([
review.food, review.price, review.service, review.environment
]) / 4.0
review.average = round(result, 1)
review.status = getReviewStatus(review.average)
stars = getStars(review.average)
review.star1 = stars[0]
review.star2 = stars[1]
review.star3 = stars[2]
review.star4 = stars[3]
review.star5 = stars[4]
if review.title == '':
msg = "Title field is requried."
else:
ck = updateRestaurantReview(review.restaurant, review)
if ck == True:
msg = 'Review has been saved.'
review.save()
else:
msg = 'Something went wrong'
else:
msg = 'Bad request.'
else:
messages.success(request, "You need to login first to write a review.")
return HttpResponseRedirect("/accounts/login/?next=" + next)
if msg != '':
messages.success(request, msg)
return HttpResponseRedirect('/restaurants/' + review.restaurant.slug +
"/review/")
def create_review(request):
if request.method == 'POST':
print "Received POST"
try:
rating = request.POST['rating']
course = request.POST['course']
author = request.POST['author']
professor = request.POST['professor']
rating = int(request.POST['rating'])
text = request.POST['text']
if rating >= 1 and rating <= 5:
courseobj = None
try:
courseobj = Course.objects.get(coursename=course)
except Course.DoesNotExist:
courseobj = Course(coursename=course)
courseobj.save()
r = Review(course=courseobj,
author=author,
professor=professor,
score=rating,
text=text)
r.save()
print "Saved %s" % r
return HttpResponseRedirect(
reverse('course_reviews', args=(course, )))
else:
raise ValueError()
except:
context = {
'error_message': "Please fill all fields",
'course': course,
'author': author,
'professor': professor,
'rating': rating,
'text': text
}
return render(request, 'reviews/create_review.html', context)
else:
return render(request, 'reviews/create_review.html', None)
def create_review(request, trail_id):
if request.method == 'POST':
if request.user.is_authenticated():
if request.POST.get('review_text') != '':
review = Review()
review.review_text = request.POST.get('review_text')
review.user = request.user
review.trail = get_object_or_404(Trail, pk=trail_id)
review.save()
return HttpResponseRedirect('/trail/%s' % str(trail_id))
else:
messages.add_message(request, messages.WARNING,
'No comment text was provided')
return HttpResponseRedirect('/trail/%s/' % str(trail_id))
return render(request, 'trails/create_review.html', {
'trail_id': trail_id,
'form': form
})
def new(request):
if not request.user.is_authenticated():
return HttpResponseForbidden
user = request.user
data = json.loads(request.body.decode('utf-8'))
restaurant = get_object_or_404(Restaurant, id=data['restaurantId'])
review = Review(title=data['title'],
body=data['body'],
user=user,
restaurant=restaurant)
try:
review.save()
except:
return HttpResponseBadRequest
return HttpResponse('OK')
def add_review(request):
if request.method == 'POST':
form = AddReview(request.POST)
if form.is_valid():
name = request.POST.get('reviewer', '')
place_name = request.POST.get('place_name', '')
image = request.POST.get('image', '')
review = request.POST.get('review', '')
r = Review(reviewer=name,
place_name=place_name,
image=image,
review=review)
r.save()
return HttpResponseRedirect('add_new_data')
else:
form = AddReview()
return render(request, 'add_review.html', {
'form': form,
})
