def create_review(request, id_ticket=None):
review = None
context = {}
if id_ticket is not None:
ticket = get_object_or_404(Ticket, pk=id_ticket)
context = {'post': {'content': ticket}}
review = Review(ticket=ticket,
rating=None,
headline=None,
body=None,
user=request.user,
time_created=None)
else:
review = Review(ticket=None,
rating=None,
headline=None,
body=None,
user=request.user,
time_created=None)
if request.method == 'GET':
form = ReviewForm(instance=review)
context['form'] = form
return render(request, 'review/addreview.html', context)
elif request.method == 'POST':
form = ReviewForm(request.POST)
if form.is_valid():
form.save()
ticket.save()
return redirect('flux')
else:
return render(request, 'review/addreview.html', context)
def save(self):
try:
title = self.validated_data['title']
body = self.validated_data['body']
rating = self.validated_data['rating']
comic = self.validated_data['comic']
# Create new review unless one already exists for this comic by this user
try:
previously_reviewed = Review.objects.get(
author__id=self.context['request'].user.id,
comic__id=comic.id)
if previously_reviewed:
raise serializers.ValidationError({
"response":
"You've already rated/reviewed this.",
"review":
ReviewSerializer(previously_reviewed).data
})
except Review.DoesNotExist:
review = Review(title=title,
body=body,
rating=rating,
author=self.context['request'].user,
comic=comic)
review.save()
return review
except KeyError as e:
raise serializers.ValidationError(
{"response": "Please include all required fields"})
def showweibo(request, id, weiboid):
iname = request.session["username"]
iuser = User.objects.get(username=iname)
iid = iuser.pk
weibo = Weibo.objects.get(pk=weiboid)
list_review = weibo.review_set.all()
if request.method == "POST":
form = reviewWeibo(request.POST)
if form.is_valid():
review = form.cleaned_data['review']
user = User.objects.get(username=request.session['username'])
r = Review(review=review, weibo=weibo, user=user)
r.save()
return render(request,
'weibo/showweibo.html',
context={
"weibo": weibo,
'list_review': list_review,
'form': form,
'iid': iid
})
else:
form = reviewWeibo()
return render(request,
'weibo/showweibo.html',
context={
"weibo": weibo,
'list_review': list_review,
'form': form,
'iid': iid
})
def __create_reviews(self):
self.review_yoga_twist = Review()
self.review_yoga_twist.owner = self.user_marie_houana
self.review_yoga_twist.revision = self.rev_yoga_twist
self.review_yoga_twist.rating = 2.5
self.review_yoga_twist.description = "Not bad!"
self.review_yoga_twist.is_draft = False
self.review_yoga_twist.save()
self.review_yoga_twist_2 = Review()
self.review_yoga_twist_2.owner = self.user_mnieber
self.review_yoga_twist_2.revision = self.rev_yoga_twist_2
self.review_yoga_twist_2.rating = 4
self.review_yoga_twist_2.description = "Good, good, good"
self.review_yoga_twist_2.is_draft = False
self.review_yoga_twist_2.save()
def handle_review_csv(csv_file, user_who_uploaded): csv_file_text_mode = codecs.iterdecode(csv_file, "utf-8") csv_reader = csv.reader(csv_file_text_mode, delimiter=',') for row in csv_reader: try: first_email = row[0] second_email = row[1] first_application = Application.objects.filter(email=first_email).first() second_application = Application.objects.filter(email=second_email).first() winner = True if row[2] == "1" else False user = user_who_uploaded time = datetime.now() in_prog = False completed = True review = Review(winner=winner, user=user, time=time, in_prog=in_prog, completed=completed) review.apps.add(first_application, second_application) review.full_clean() except ValidationError as e: """Fields are not valid.""" return True, "The csv fields are not valid." else: review.save() return False, "Uploaded reviews"
def setUp(self):
with open('secrets.json', 'r') as f:
secret_key = json.load(f)
LoginPlatform(name="airbnb").save()
User(id=1,
email='*****@*****.**',
password=bcrypt.hashpw("qweasd123!".encode('utf-8'),
bcrypt.gensalt()).decode('utf-8'),
first_name='jiwon',
last_name='ko',
birth_date=datetime.datetime.strptime("1997-2-20", "%Y-%m-%d"),
is_host=False,
platform=LoginPlatform.objects.get(name="airbnb")).save()
Amenity(name='amenity').save()
Room(id=1,
title='Room title',
address='Room 주소',
max_personnal='10',
bed_room='침실',
bed='퀸 사이즈',
bath_room='욕실 한 개',
price=100000,
latitude=30,
longitude=50,
description='room 설명').save()
BookingStatus(status='예약완료').save()
PaymentMethod(name='체크카드').save()
Booking(id=1,
check_in=datetime.datetime.strptime("2020-08-10", "%Y-%m-%d"),
check_out=datetime.datetime.strptime("2020-08-12", "%Y-%m-%d"),
price=100000,
cleaning_expense=10000,
service_tax=3000,
accomodation_tax=3000,
adult=3,
children=1,
infants=0,
user=User.objects.get(email='*****@*****.**'),
room=Room.objects.get(title='Room title'),
status=BookingStatus.objects.get(status='예약완료'),
payment_method=PaymentMethod.objects.get(name='체크카드'),
created_at=datetime.datetime.strptime("2020-08-09",
"%Y-%m-%d")).save()
Review(booking=Booking.objects.get(id=1),
content='리뷰 내용',
cleanliness_score=4.0,
communication_score=5.0,
check_in_score=3.0,
accuracy_score=2.5,
location_score=3.5,
satisfaction_score=4.0,
created_at=datetime.datetime.strptime("2020-09-01",
"%Y-%m-%d")).save()
self.token = jwt.encode(
{
'email': User.objects.get(email='*****@*****.**').email
},
secret_key['SECRET_KEY'],
algorithm=ALGORITHM).decode('utf-8')
def setUp(self):
self.instructor = Instructor(name="Teacher")
self.instructor.save()
self.review = Review(
section=get_or_create_course_and_section("CIS-120-001", TEST_SEMESTER)[1],
instructor=self.instructor,
)
self.review.save()
def reviews(request):
if ('author' in request.GET and 'comment' in request.GET
and request.GET['author'] != '' and request.GET['comment'] != ''):
review = Review(author=request.GET['author'], text=request.GET['comment'])
review.save()
all_reviews = reversed(Review.objects.all())
return render(request, 'reviews.html', {'reviews': all_reviews})
def __get_or_create_review(self, request, revision, all_reviews):
review = all_reviews.filter(owner=request.global_user).first()
if not review:
review = Review()
review.owner = request.global_user
review.revision = revision
review.save()
return review
def post(self, request, restaurant_id):
user_who_wrote_review = request.user
request_time = datetime.now(timezone.utc)
review_data = json.loads(request.body)
restaurant_for_review = Restaurants.objects.get(id=restaurant_id)
orders_of_user = Order.objects.filter(
user=user_who_wrote_review,
restaurant=restaurant_for_review).order_by('-id')
if len(orders_of_user) == 0:
return JsonResponse({'message': 'INVALID_USER'}, status=401)
latest_order_of_user = orders_of_user[0]
date_of_latest_order = latest_order_of_user.created_at #가장 최근 주문의 생성날짜
#주문한지 7일이 지났다면 리뷰를 쓸수 없음
days = 60 * 60 * 24
if (request_time - date_of_latest_order).total_seconds() > (7 * days):
return JsonResponse({'message': 'EXPIRED_PERIOD'}, status=401)
rating = review_data['rating']
#리뷰 등록
Review(
order=latest_order_of_user,
user=user_who_wrote_review,
restaurant=restaurant_for_review,
comment=review_data['comment'],
rating_taste=rating['taste'],
rating_delivery=rating['delivery'],
rating_quantity=rating['quantity'],
rating_avg=sum(rating.values()) / len(rating),
created_at=request_time,
).save()
saved_review = Review.objects.latest('created_at')
#menu와 review 연결
join_review_menu_list = []
for i in range(len(review_data['menus'])):
join_review_menu_list.append(
JoinReviewMenu(
review=saved_review,
menu=Menus.objects.get(id=review_data['menus'][i]['id']),
amount=review_data['amounts'][i],
))
JoinReviewMenu.objects.bulk_create(join_review_menu_list)
#review img와 review 연결
if len(review_data['review_img']) != 0:
review_img_list = []
for i in range(len(review_data['review_img'])):
review_img_list.append(
ReviewImage(
review=saved_review,
review_image=review_data['review_img'][i],
))
ReviewImage.objects.bulk_create(review_img_list)
return JsonResponse({'message': 'SUCCESS'}, status=200)
def create(request):
# 여기서 글을 DB에 저장
title = request.GET["title"]
body = request.GET["body"]
review = Review()
review.title = title
review.body = body
review.pub_date = timezone.now()
review.save()
return redirect('home')
def test_one_rating(self):
review1 = Review(
rating = 5,
reviewer = self.user,
parkingspot= self.test_spot1
)
review1.save()
rating = self.test_spot1.get_avg_rating()
self.assertEqual(5, rating)
review1.delete()
def review_create(request):
# Получение данных из формы в переменную
form = ReviewForm(request.POST)
dbl.log("Форма" + str(form))
# global list_crumb_for_software
list_crumb_for_software = [['Главная', 'main:index'],
['Отзывы', 'review:list_review']]
# Получение данных из формы и сохранение в бд
if request.method == "POST":
try:
# Проверка принадлежности запрашиваемого заказа к текущему пользователю
# Получения пользователя
user = CustomUser.get_user(request)
# Здесь автоматически проверяются все поля формы методами clean_...
if form.is_valid():
new_review = Review()
new_review.kind = 'com'
if user:
new_review.client = user
new_review.content = form.cleaned_data['content']
new_review.star = form.cleaned_data['star']
new_review.name = form.cleaned_data['name']
new_review.email_phone = form.cleaned_data['email_phone']
new_review.save()
addition_file = request.FILES.getlist('file')
# Сохранение приложений файлов к отзыву (происходит тогда, когда все поля валидны)
for file in addition_file:
dbl.log("777")
new_addition = Review_Addition()
new_addition.review = new_review
new_addition.photo = file
new_addition.save()
return redirect('review:review_success')
except Exception as error:
pass
dbl.log("Ошибка работы с отзывом" + str(error))
rating = [5, 4, 3, 2, 1]
return render(request, 'review/review_create.html', {
'form': form,
'rating': rating,
'list_crumb': list_crumb_for_software
})
def post(self, request, pk=None):
rating = request.data.get("rating")
user_one = self.request.user
user_two = User.objects.get(id=pk)
reviewed = Review.objects.filter(user_id=user_one.id,
rated_user_id=user_two.id).delete()
review = Review(user_id=user_one.id,
rated_user_id=user_two.id,
rating=rating)
review.save()
return Response({"Message": "Rating submitted"})
def test_validate_review_post_request_review_exists(self):
# Review exists already
test_data = {"courseCode": "TDT4290",
"score": 1,
"workload": 1,
"difficulty": 1,
"reviewText": "Lorem ipsum"}
test_review = Review(user_email="*****@*****.**", course_code="TDT4290", score=4, workload=5, difficulty=3,
review_text="Test review", full_name="Test Testesen", study_programme="MTDT")
test_review.save()
with self.assertRaises(ValueError):
validate_review_post_request(test_data, ["TDT4290", "TMA4125"], "*****@*****.**")
def review(request, pk):
if "form_submit" in request.POST:
form = ReviewForm(request.POST)
if form.is_valid():
r = Review(
user=request.user,
location=Location.objects.only("id").get(id=pk),
content=form.cleaned_data["content"],
rating=form.cleaned_data["rating"],
)
r.save()
return HttpResponseRedirect(reverse("location", args=(pk, )))
def setUp(self) -> None:
courses = [
Course(course_code="TDT4120", course_name="AlgDat", credit=7.5, average_grade=1, pass_rate=100.0),
Course(course_code="TMA4100", course_name="Matte 1", credit=7.5, average_grade=1, pass_rate=100.0),
Course(course_code="EXPH0004", course_name="Exphil", credit=7.5, average_grade=1, pass_rate=100.0),
Course(course_code="TFE4101", course_name="KretsDigtek", credit=7.5, average_grade=1, pass_rate=100.0),
Course(course_code="TFY4125", course_name="Fysikk", credit=7.5, average_grade=1, pass_rate=100.0),
Course(course_code="TDT4290", course_name="KPro", credit=7.5, average_grade=1, pass_rate=100.0),
Course(course_code="TDT4136", course_name="AI Intro", credit=7.5, average_grade=1, pass_rate=100.0),
]
for c in courses: c.save()
reviews = [
Review(id=1, course_code="TMA4100", user_email="*****@*****.**", score=5, workload=1, difficulty=2,
review_text="Bra f*g", full_name="Test test", study_programme="MTDT"),
Review(id=2, course_code="TMA4100", user_email="*****@*****.**", score=3, workload=0, difficulty=0,
review_text="Givende", full_name="KPro Kproson", study_programme="MTKPRO"),
Review(id=3, course_code="TMA4100", user_email="*****@*****.**", score=4, workload=1, difficulty=2,
review_text="Lattice", full_name="Heman 2015", study_programme="MTDT"),
Review(id=4, course_code="TDT4120", user_email="*****@*****.**", score=5, workload=2, difficulty=2,
review_text="Kult", full_name="KPro Kproson", study_programme="MTKPRO"),
Review(id=5, course_code="TDT4120", user_email="*****@*****.**", score=1, workload=0, difficulty=0,
review_text="Kjipt", full_name="Test test", study_programme="MTDT"),
Review(id=6, course_code="EXPH0004", user_email="*****@*****.**", score=3, workload=1, difficulty=0,
review_text="<3", full_name="KPro Kproson", study_programme="MTDT")
]
for r in reviews: r.save()
UserAuth(expiring_token="valid_token", access_token="valid_token", user_email="*****@*****.**").save()
User.objects.create(username="******", email="*****@*****.**").save()
def setUp(self):
self.course, self.section = create_mock_data("CIS-120-001", TEST_SEMESTER)
_, self.section2 = create_mock_data("CIS-120-002", TEST_SEMESTER)
self.instructor = Instructor(name="Person1")
self.instructor.save()
self.rev1 = Review(
section=create_mock_data("CIS-120-003", "2005C")[1],
instructor=self.instructor,
responses=100,
)
self.rev1.save()
self.rev1.set_averages(
{
"course_quality": 4,
"instructor_quality": 4,
"difficulty": 4,
}
)
self.instructor2 = Instructor(name="Person2")
self.instructor2.save()
self.rev2 = Review(
section=create_mock_data("CIS-120-002", "2015A")[1],
instructor=self.instructor2,
responses=100,
)
self.rev2.instructor = self.instructor2
self.rev2.save()
self.rev2.set_averages(
{
"course_quality": 2,
"instructor_quality": 2,
"difficulty": 2,
}
)
self.section.instructors.add(self.instructor)
self.section2.instructors.add(self.instructor2)
self.client = APIClient()
set_semester()
def setUp(self):
UserAuth(expiring_token="valid_token",
access_token="valid_token",
user_email="*****@*****.**").save()
self.api_client = APIClient()
self.api_client.credentials(HTTP_AUTHORIZATION="valid_token")
User.objects.create(username="******",
email="*****@*****.**").save()
User.objects.create(username="******",
email="*****@*****.**").save()
Course(course_code="TMA4100",
course_name="Matte 1",
credit=7.5,
average_grade=1,
pass_rate=100.0).save()
Review(course_code="TMA4100",
user_email="*****@*****.**",
score=5,
workload=1,
difficulty=2,
review_text="Bra f*g",
full_name="Test test",
study_programme="MTDT").save()
Review(course_code="TMA4100",
user_email="*****@*****.**",
score=3,
workload=1,
difficulty=2,
review_text="Givende",
full_name="KPro Kproson",
study_programme="MTKPRO").save()
self.curr_user = User.objects.get(username="******")
self.other_user = User.objects.get(username="******")
self.review1 = Review.objects.get(course_code="TMA4100",
user_email="*****@*****.**")
self.review2 = Review.objects.get(course_code="TMA4100",
user_email="*****@*****.**")
Upvote(user=self.curr_user, review=self.review1).save()
Upvote(user=self.other_user, review=self.review1).save()
def test_insert_review(self):
""" Test if the review document is inserted properly """
req = self.factory.post('/api/review/insert/',
self.expected,
content_type='application/json')
actual = json.loads(view_response.insert_review_page(req).content)
del actual['Timestamp']
expected = Review(_id=actual['_id'],
restaurant_id="111111111111111111111111",
user_email="*****@*****.**",
title="title2",
content="content2",
rating=3)
self.assertDictEqual(model_to_dict(expected), actual)
def create(self, request, *args, **kwargs):
restaurant = Restaurant.objects.get(id=kwargs['pk'])
rating = self.request.data['rating']
if rating in [1, 2, 3, 4, 5]:
review = Review(author=self.request.user,
rating=rating,
restaurant=restaurant,
content=self.request.data['content'])
review.save()
return Response(self.get_serializer(review).data)
else:
return JsonResponse(
{'detail': 'Please provide valid rating(1 to 5)!'})
def review(request):
user = request.user
if Profile.objects.filter(user=user, is_council=True).exists():
submission = request.POST.get('task')
feedback = request.POST.get('feedback')
rating = request.POST.get('rating')
review = Review(user=Profile.objects.get(user=user),
submission_id=submission,
feedback=feedback,
rating=rating)
review.save()
return redirect('/portal/home?success=True')
return redirect('/portal/home')
def test_multiple_ratings(self):
review1 = Review(
rating = 5,
reviewer = self.user,
parkingspot= self.test_spot1
)
review2 = Review(
rating = 4,
reviewer = self.user,
parkingspot= self.test_spot1
)
review3 = Review(
rating = 3,
reviewer = self.user,
parkingspot= self.test_spot1
)
review1.save()
review2.save()
review3.save()
rating = self.test_spot1.get_avg_rating()
self.assertEqual(4, rating)
review1.delete()
review2.delete()
review3.delete()
def setUpClass(cls):
"""Method called to prepare the test fixture."""
super(BaseViewTestCase, cls).setUpClass()
# create user
cls.user = get_user_model().objects.create(
username='******',
email='*****@*****.**'
)
cls.user.set_password('123test')
cls.user.save()
# create pictures
small_gif = (
b'\x47\x49\x46\x38\x39\x61\x01\x00\x01\x00\x00\x00\x00\x21\xf9\x04'
b'\x01\x0a\x00\x01\x00\x2c\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02'
b'\x02\x4c\x01\x00\x3b'
)
cls.picture = Picture(
title='test_title',
file_name=SimpleUploadedFile(
name='small.gif', content=small_gif, content_type='image/gif'),
description='test_description',
technical='test_technical',
camera='test_camera',
place='test_place',
taken_date=date(2021, 1, 1),
user=cls.user,
upload_date=datetime.now(),
)
cls.picture.save()
cls.review = Review(
score_intention=4,
score_technical=4,
score_picture=4,
score_global=4,
comment_intention="test",
picture=cls.picture,
user=cls.user
)
cls.review.save()
cls.client_login = Client(HTTP_REFERER=reverse('gallery:home'))
cls.logged_in = cls.client_login.login(
username='******', password='******')
def test_can_review_review_exists(self):
c = APIClient()
c.credentials(HTTP_AUTHORIZATION='valid_token')
Review(course_code="TMA4100",
user_email="*****@*****.**",
score=5,
workload=1,
difficulty=2,
review_text="Bra f*g",
full_name="Test testesen",
study_programme="MTDT").save()
with patch("course.views.Course.objects.filter") as mock_course_db:
mock_course_db.return_value = MockQuerySet(
[Course.create("AAA9999", "Test course", 0, 0, 100.0)])
res = c.get("/review/check/?courseCode=TMA4100")
self.assertEqual(res.status_code, 200)
self.assertEqual(res.data, 2)
def post(self, request, *args, **kwargs):
submission = Submission.objects.get(pk=kwargs.get('pk', None))
if submission.status == 0:
submission.status = 1
submission.save()
return redirect('review', submission.pk)
elif submission.status == 1:
form = ReviewForm(request.POST)
if form.is_valid():
review = Review(reviewer=request.user.judge,
submission=submission,
comment=request.POST['comment'])
review.save()
submission.status = request.POST['status']
submission.save()
return redirect('reviews')
def post(self, request, pk, host):
user = request.user
data = json.loads(request.body)
rating = Rating.objects.create(
cleanliness = data['inputs'].get('cleanliness', 0),
communication = data['inputs'].get('communication', 0),
check_in = data['inputs'].get('check_in', 0),
accuracy = data['inputs'].get('accuracy', 0),
location = data['inputs'].get('location', 0),
value = data.get('value', 0))
Review(
room_id = pk,
reviewer_id = TOHOST,
host_id = host,
guest_id = user.id,
rating = rating,
content = data['inputs'].get('content', ' ')).save()
return HttpResponse(status = 200)
def create_mock_data_with_reviews(code, semester, number_of_instructors):
course, section = create_mock_data(code, semester)
reviews = []
for i in range(1, number_of_instructors + 1):
instr, _ = Instructor.objects.get_or_create(name="Instructor" + str(i))
section.instructors.add(instr)
review = Review(section=section, instructor=instr, responses=100)
review.save()
review.set_averages(
{
"course_quality": 4 / i,
"instructor_quality": 4 / (i + 1),
"difficulty": 4 / (i + 2),
"work_required": 4 / (i + 3),
}
)
reviews.append(review)
return course, section, reviews
def save(self, commit=True):
"""
Though this form is linked to an Application instance, it's actually
used to save the corresponding review instance.
"""
data = {
"reviewer": self.request.user,
"interest": int(self.cleaned_data["interest"]),
"experience": int(self.cleaned_data["experience"]),
"quality": int(self.cleaned_data["quality"]),
"reviewer_comments": self.cleaned_data["reviewer_comments"],
"status": self.cleaned_data["status"],
}
review = getattr(self.instance, "review", None)
if review is None:
data["application"] = self.instance
review = Review(**data)
else:
old_status = review.status
for attr, value in data.items():
setattr(review, attr, value)
# If they were previously waitlisted and the status has been changed to
# accepted or rejected, allow sending a new decision by clearing
# decision_sent_date
if old_status == "Waitlisted" and review.status != old_status:
review.decision_sent_date = None
if commit:
review.save()
else:
self.review = review
# If commit=False, super().save(commit=False) will set
# self.save_m2m = self._save_m2m, for the user to call at a later time.
# This will now also save the review instance.
self._save_m2m = self._save_m2m_and_review
return super().save(commit)
def get_reviews(url, movie, base=None):
from requests import get
from bs4 import BeautifulSoup as BS
from time import sleep
from random import randint
reviews = 0
try:
response = get(url)
html_soup = BS(response.text, 'html.parser')
review_containers = html_soup.find_all('div',
class_='imdb-user-review')
for review in review_containers:
title, comment, date, rating = get_review_info(review)
review = Review()
review.title = title
review.comment = comment
review.date = date
review.movie = movie
review.rating = rating
review.url = url
review.save()
if html_soup.find('div', class_='load-more-data') is not None:
if base is None:
base = url
_key = html_soup.find('div', class_='load-more-data')['data-key']
_url = base + '/_ajax?paginationKey=' + _key
sleep(randint(3, 8))
get_reviews(_url, movie, base)
except Exception as e:
print('ERROR: ', e)
print(movie, url)
return reviews
