def test_results_200(self):
self.assertEqual(self.room.users.count(), 1)
self.assertEqual(self.room.users.first(), self.admin)
Rating.objects.bulk_create([
Rating(user=self.admin, movie=movie, score=5)
for movie in list(self.room.movies.all())
])
self.assertTrue(self.room.users_are_ready)
self.assertEqual(self.room.results.count(), 0)
url = f'{self.URL}/{self.room.slug}/results'
r = self.client.get(url, **self.http_admin_auth)
self.assertEqual(r.status_code, 200)
r_json = r.json()
self.assertEqual(len(r_json), 2)
self.assertEqual(r_json['slug'], self.room.slug)
self.assertEqual(len(r_json['results']), constants.RESULTS_MOVIES)
self.room.refresh_from_db()
self.assertEqual(self.room.results.count(), constants.RESULTS_MOVIES)
# can be called again
r_2 = self.client.get(url, **self.http_admin_auth)
self.assertEqual(r_2.status_code, 200)
r_2_json = r_2.json()
self.assertEqual(r_2_json, r_json)
def test_rating_str(self):
# test that rating model string is what you expect
test_name = Rating(
reviewer=self.user1,
rating=3
)
self.assertEqual(str(test_name), "{0} by {1}".format(test_name.rating, self.user1.username))
def test_get_or_create_results(self):
room = Room.objects.create_room(**{
'slug': self.slug,
'admin': self.user
})
self.assertEqual(list(room.results.all()), [])
user_2 = User.objects.create_user(**USER_CHI)
room.sync_user(user_2)
admin_rated_count = room.users.rated_count(room)[0]['rated_count']
user_2_rated_count = room.users.rated_count(room)[1]['rated_count']
self.assertTrue(admin_rated_count < constants.CHALLENGE_MOVIES)
self.assertTrue(user_2_rated_count < constants.CHALLENGE_MOVIES)
self.assertEqual(room.users_are_ready, False)
with self.assertRaises(RoomUsersNotReady):
room.get_or_create_results()
Rating.objects.bulk_create([
Rating(user=self.user, movie=movie, score=1)
for movie in list(room.movies.all())
])
admin_rated_count = room.users.rated_count(room)[0]['rated_count']
self.assertEqual(admin_rated_count, constants.CHALLENGE_MOVIES)
self.assertEqual(room.users_are_ready, False)
with self.assertRaises(RoomUsersNotReady):
room.get_or_create_results()
Rating.objects.bulk_create([
Rating(user=user_2, movie=movie, score=1)
for movie in list(room.movies.all())
])
user_2_rated_count = room.users.rated_count(room)[1]['rated_count']
self.assertEqual(user_2_rated_count, constants.CHALLENGE_MOVIES)
self.assertEqual(room.users_are_ready, True)
results = room.get_or_create_results()
room.refresh_from_db()
self.assertEqual(list(room.results.all()), list(results.all()))
self.assertEqual(results.count(), constants.RESULTS_MOVIES)
results_2 = room.get_or_create_results()
self.assertEqual(list(results_2.all()), list(results.all()))
def add(request):
if request.method == "POST":
form = NewProfForm(request.POST)
if form.is_valid():
prof = form.cleaned_data
name = prof["name"]
marks = prof["marks"]
obj = Rating(professor=name, rating=marks)
obj.save()
print("redirecting...")
return redirect("rating")
else:
return render(request, "rating/add.html"), {"form": form}
return render(request, "ratings/add.html", {"form": NewProfForm()})
def avaliarSubmit(request, idAvalia):
url = request.META.get('HTTP_REFERER')
user = request.user
try:
historico = HistoricoAlugados.objects.get(id=idAvalia)
except ObjectDoesNotExist:
return render(request, 'home/termosdeuso.html')
usuario = ''
locadorUser = ''
locatarioUser = ''
if user == historico.locador:
historico.avaliadoPeloLocador = True
historico.save()
usuario = historico.locatario
if user == historico.locatario:
historico.avaliadoPeloLocatario = True
historico.save()
usuario = historico.locador
if request.method == 'POST':
form = RatingForm(request.POST)
if form.is_valid():
data = Rating()
data.de = user
data.para = usuario
data.text = form.cleaned_data['text']
data.rate = form.cleaned_data['rate']
data.save()
messages.info(request, 'Agradecemos a sua avaliação!')
user = request.user
avaliacoes = HistoricoAlugados.objects.filter(Q(locador=user) | Q(locatario=user) & Q(encerrado=True))
arrayPendentes = []
for avaliacao in avaliacoes:
if user == avaliacao.locador:
if avaliacao.avaliadoPeloLocador == False:
arrayPendentes.append(avaliacao)
if user == avaliacao.locatario:
if avaliacao.avaliadoPeloLocatario == False:
arrayPendentes.append(avaliacao)
return render(request, 'user/avaliacoesPendentes.html', {'avaliacoes': arrayPendentes})
def average_rating_for_zipcode(request, zipcode):
"""
Get average rating values for zipcode.
"""
ratings = Rating.objects.filter(zipcode=zipcode)
ratings_count = ratings.count()
if(ratings_count == 0):
return Response(status=status.HTTP_404_NOT_FOUND)
# Get all rated values
total_sum = 0.0
culture_sum = 0.0
infrastructure_sum = 0.0
green_sum = 0.0
safety_sum = 0.0
for rating in ratings:
total_sum += rating.total
culture_sum += rating.culture
infrastructure_sum += rating.infrastructure
green_sum += rating.green
safety_sum += rating.safety
# Get rounded average values
total_average = int(round(total_sum / ratings_count))
culture_average = int(round(culture_sum / ratings_count))
infrastructure_average = int(round(infrastructure_sum / ratings_count))
green_average = int(round(green_sum / ratings_count))
safety_average = int(round(safety_sum / ratings_count))
# Create a new Rating object with average values
average_rating = Rating(zipcode=zipcode, user_id='average',
total=total_average, culture=culture_average, infrastructure=infrastructure_average,
green=green_average, safety=safety_average)
serializer = RatingSerializer(average_rating)
return Response(serializer.data)
def test_room_ratings_count(self):
movies_2018 = [
Movie.objects.create(title=f'title_{i}', year=2018)
for i in range(CHALLENGE_MOVIES)
]
movies_2019 = [
Movie.objects.create(title=f'title_{i}', year=2019)
for i in range(CHALLENGE_MOVIES)
]
user_1 = User.objects.create_session_user(USER_CHI['name'])
user_2 = User.objects.create_session_user(USER_JOAO['name'])
room = Room.objects.create(admin=user_1, slug='slug')
room.sync_user(user_1)
room.sync_user(user_2)
room.movies.set(movies_2018)
self.assertEqual(room.users.count(), 2)
self.assertEqual(room.movies.count(), CHALLENGE_MOVIES)
# 2018 movies ratings
ratings = [
Rating(user=user_1, movie=movies_2018[0], score=1),
Rating(user=user_1, movie=movies_2018[3], score=2),
Rating(user=user_1, movie=movies_2018[8], score=3),
# 2019 movie ratings
Rating(user=user_1, movie=movies_2019[1], score=1),
Rating(user=user_1, movie=movies_2019[7], score=3),
# user 2
Rating(user=user_2, movie=movies_2019[0], score=1),
]
Rating.objects.bulk_create(ratings)
User.objects.create_session_user('not in the room')
self.assertEqual(User.objects.count(), 3)
qs = User.objects.rated_count(room=room)
self.assertEqual(qs.count(), 2)
self.assertIn({'name': USER_CHI['name'], 'rated_count': 3}, qs)
self.assertIn({'name': USER_JOAO['name'], 'rated_count': 0}, qs)
from ratings.models import Rating
from ratings.serializers import RatingSerializer
from rest_framework.renderers import JSONRenderer
from rest_framework.parsers import JSONParser
rating = Rating(route_id=1,
user_id=1,
car_rating=4,
driver_rating=3,
average_rating=3.5,
comment='I liked the travel')
rating.save()
rating = Rating(route_id=1,
user_id=2,
car_rating=5,
driver_rating=3,
average_rating=4,
comment='The driver was awesome! I wanna marry him')
rating.save()
serializer = RatingSerializer(rating)
serializer.data
content = JSONRenderer().render(serializer.data)
content
from django.utils.six import BytesIO
stream = BytesIO(content)
data = JSONParser().parse(stream)
# {{{ Insert new ratings
Rating.objects.bulk_create([
Rating(
period=period,
player=p['player'],
prev=p['rating'],
rating=p['new_ratings']['M'],
rating_vp=p['new_ratings']['P'],
rating_vt=p['new_ratings']['T'],
rating_vz=p['new_ratings']['Z'],
dev=p['new_devs']['M'],
dev_vp=p['new_devs']['P'],
dev_vt=p['new_devs']['T'],
dev_vz=p['new_devs']['Z'],
comp_rat=p['perfs']['M'],
comp_rat_vp=p['perfs']['P'],
comp_rat_vt=p['perfs']['T'],
comp_rat_vz=p['perfs']['Z'],
bf_rating=p['new_ratings']['M'],
bf_rating_vp=p['new_ratings']['P'],
bf_rating_vt=p['new_ratings']['T'],
bf_rating_vz=p['new_ratings']['Z'],
bf_dev=p['new_devs']['M'],
bf_dev_vp=p['new_devs']['P'],
bf_dev_vt=p['new_devs']['T'],
bf_dev_vz=p['new_devs']['Z'],
decay=p['rating'].decay +
1 if p['rating'] and len(p['wins']) == 0 else 0,
) for p in players.values() if p['player'].id in insert_ids
])
def signup(request):
sign_up_page = request.COOKIES.get(SIGN_UP_PAGE, SIGN_UP_PAGE_FIRST)
sign_up_get_form = SignUpForm1() if sign_up_page == SIGN_UP_PAGE_FIRST \
else SignUpForm2() if sign_up_page == SIGN_UP_PAGE_SECOND \
else SignUpForm3() if sign_up_page == SIGN_UP_PAGE_THIRD \
else SignUpForm4()
if request.method == GET:
sign_up_stage_page = ugettext_lazy("Регистрация - этап {}")
sign_up_stage_page = sign_up_stage_page.format(sign_up_page)
submit_value = ugettext_lazy("Далее")
has_error, error = request.COOKIES.get(SIGN_UP_COOKIE_ERROR, IS_OK), NONE
if sign_up_page == SIGN_UP_PAGE_SECOND:
sign_up_get_form.fields[PHONE_NUMBER].initial = "+7"
submit_value = ugettext_lazy("Получить код")
if has_error == IS_NOT_OK:
error = ugettext_lazy("Уже существует аккаунт с таким номером телефона или номер телефона некорректен")
elif sign_up_page == SIGN_UP_PAGE_THIRD:
sign_up_get_form.fields[PHONE_NUMBER].initial = request.COOKIES.get(SIGN_UP_COOKIE_PHONE_NUMBER)
submit_value = ugettext_lazy("Подтвердить код")
if has_error == IS_NOT_OK:
error = ugettext_lazy("Введенный код не подтвержден")
elif sign_up_page == SIGN_UP_PAGE_FOURTH:
sign_up_get_form.fields[PHONE_NUMBER].initial = request.COOKIES.get(SIGN_UP_COOKIE_PHONE_NUMBER)
sign_up_get_form.fields[CODE_FOR_PHONE_NUMBER].initial = request.COOKIES.get(SIGN_UP_COOKIE_PHONE_NUMBER_CODE)
submit_value = ugettext_lazy("Создать аккаунт")
context = {
FORM: sign_up_get_form,
STAGE: sign_up_stage_page,
SUBMIT_VALUE: submit_value,
ERROR: error
}
response = render(request, "sportsmen/signup.html", context=context)
response.set_cookie(SIGN_UP_COOKIE_ERROR, IS_OK, max_age=SIGN_UP_PAGE_COOKIE_AGE)
return response
elif request.method == POST:
sign_up_post_form = SignUpForm1(request.POST) if sign_up_page == SIGN_UP_PAGE_FIRST \
else SignUpForm2(request.POST) if sign_up_page == SIGN_UP_PAGE_SECOND \
else SignUpForm3(request.POST) if sign_up_page == SIGN_UP_PAGE_THIRD \
else SignUpForm4(request.POST)
if sign_up_page == SIGN_UP_PAGE_FIRST:
if sign_up_post_form.is_valid():
response = redirect("signup")
response.set_cookie(
SIGN_UP_PAGE,
SIGN_UP_PAGE_SECOND,
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
response.set_cookie(
SIGN_UP_COOKIE_FIRST_NAME,
"|".join(str(ord(element)) for element in sign_up_post_form.cleaned_data[FIRST_NAME]),
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
response.set_cookie(
SIGN_UP_COOKIE_LAST_NAME,
"|".join(str(ord(element)) for element in sign_up_post_form.cleaned_data[LAST_NAME]),
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
response.set_cookie(
SIGN_UP_COOKIE_DAY,
sign_up_post_form.cleaned_data[DAY],
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
response.set_cookie(
SIGN_UP_COOKIE_MONTH,
sign_up_post_form.cleaned_data[MONTH],
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
response.set_cookie(
SIGN_UP_COOKIE_YEAR,
sign_up_post_form.cleaned_data[YEAR],
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
response.set_cookie(
SIGN_UP_COOKIE_GENDER,
sign_up_post_form.cleaned_data[GENDER],
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
return response
elif sign_up_page == SIGN_UP_PAGE_SECOND:
response = redirect("signup")
is_valid, country_region, phone_number = True, request.POST.get(COUNTRY_REGION), request.POST.get(PHONE_NUMBER)
if (country_region == "+380" and len(phone_number) < 18) or \
(country_region == "+375" and len(phone_number) < 17) or \
(country_region == "+77" and len(phone_number) < 16) or \
(country_region == "+7" and len(phone_number) < 16):
is_valid = False
if sign_up_post_form.is_valid() and is_valid:
try:
Sportsman.manager.get(phone_number=sign_up_post_form.cleaned_data[PHONE_NUMBER])
response.set_cookie(
SIGN_UP_COOKIE_ERROR,
IS_NOT_OK,
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
return response
except ObjectDoesNotExist:
response.set_cookie(
SIGN_UP_PAGE,
SIGN_UP_PAGE_THIRD,
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
response.set_cookie(
SIGN_UP_COOKIE_PHONE_NUMBER,
sign_up_post_form.cleaned_data[PHONE_NUMBER],
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
send_code_to_activate_phone_number.delay(sign_up_post_form.cleaned_data[PHONE_NUMBER])
return response
response.set_cookie(
SIGN_UP_COOKIE_ERROR,
IS_NOT_OK,
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
return response
elif sign_up_page == SIGN_UP_PAGE_THIRD:
if sign_up_post_form.is_valid():
code_for_phone_number = sign_up_post_form.cleaned_data[CODE_FOR_PHONE_NUMBER]
phone_number = request.COOKIES.get(SIGN_UP_COOKIE_PHONE_NUMBER)
phone_number_verified = send_code_to_verify_phone_number(phone_number, code_for_phone_number)
response = redirect("signup")
if phone_number_verified:
response.set_cookie(
SIGN_UP_PAGE,
SIGN_UP_PAGE_FOURTH,
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
response.set_cookie(
SIGN_UP_COOKIE_PHONE_NUMBER_CODE,
code_for_phone_number,
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
else:
response.set_cookie(
SIGN_UP_COOKIE_ERROR,
IS_NOT_OK,
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
return response
elif sign_up_page == SIGN_UP_PAGE_FOURTH:
if sign_up_post_form.is_valid():
first_name_cookie = request.COOKIES.get(SIGN_UP_COOKIE_FIRST_NAME).split("|")
last_name_cookie = request.COOKIES.get(SIGN_UP_COOKIE_LAST_NAME).split("|")
first_name_cookie = [int(element) for element in first_name_cookie if element]
last_name_cookie = [int(element) for element in last_name_cookie if element]
user = User()
user.save()
user.username = user.pk
user.first_name = "".join(map(chr, first_name_cookie))
user.last_name = "".join(map(chr, last_name_cookie))
user.set_password(sign_up_post_form.cleaned_data[PASSWORD])
user.save()
sportsman = Sportsman()
sportsman.phone_number = request.COOKIES.get(SIGN_UP_COOKIE_PHONE_NUMBER)
sportsman.gender = request.COOKIES.get(SIGN_UP_COOKIE_GENDER)
sportsman.birthday = datetime(
int(request.COOKIES.get(SIGN_UP_COOKIE_YEAR)),
int(request.COOKIES.get(SIGN_UP_COOKIE_MONTH)),
int(request.COOKIES.get(SIGN_UP_COOKIE_DAY))
).date()
sportsman.avatar = "man.png" if request.COOKIES.get(SIGN_UP_COOKIE_GENDER) == "1" else "woman.png"
sportsman.athlete = user
sportsman.save()
rating = Rating()
rating.athlete = user
rating.save()
log_in(request, user)
response = redirect("sportsmen-index")
response.set_cookie(
SIGN_UP_PAGE,
SIGN_UP_PAGE_FIRST,
max_age=SIGN_UP_PAGE_COOKIE_AGE
)
return response
return redirect("signup")
