def add_bus_rating(request): if request.method == "POST": try: business = Business.objects.get(id=request.POST["bid"]) except Business.DoesNotExist: print("bus does not exist!") return HttpResponse("{'success': 'false'}") rat = request.POST["rating"] try: rating = Rating.objects.get(business=business, user=request.user) except Rating.DoesNotExist: logger.debug("In vote create a new rating!") rating = Rating(business=business, user=request.user, rating=rat) else: Rating.objects.filter(business=business, user=request.user).delete() rating = Rating(business=business, user=request.user, rating=rat) rating.save() response_data = dict() response_data["bid"] = str(request.POST["bid"]) response_data["success"] = "true" response_data["rating"] = rat context = {} business.rating = rating.rating context["business"] = get_single_bus_data(business, request.user) return render_to_response("ratings/listing/rate_data.html", context) # return HttpResponse("{'success':'true', 'rating': '" + str(rat) + "'}") else: raise Http404("What are you doing here?")
def generate_nmf_test(numFactors, density): allUsers = User.objects.all() allBusinsses = Business.objects.all() random.seed(666) newP = [] for u in range(0, allUsers.count()): if u not in newP: newP.append([]) for k in range(0, numFactors): rif = random.uniform(0, 1) newP[u].append(rif) newQ = [] for k in range(0, numFactors): newQ.append([]) for j in range(0, allBusinsses.count()): rif = random.uniform(0, 1) newQ[k].append(rif) initR = dot(newP, newQ) i = 0 for u in allUsers: j = 0 for b in allBusinsses: chance = random.uniform(0, 1) if(chance < density): rat = Rating(business=b, username=u, rating=float(initR[i][j])) rat.save() j = j + 1 i = i + 1
def import_ratings(apps, schema_editor): with open('ratings/data/ratings.csv', encoding='latin-1') as f: ratings = csv.reader(f, delimiter="\t") for row in ratings: rater = Rater.objects.get(id=row[0]) movie = Movie.objects.get(id=row[1]) rating = Rating(rater=rater, movie=movie, score=row[2]) rating.save()
def rateItemInDb(item, user, value): # logger.debug("Adding rating: item [%s], user [%s], value [%s]" % (item, user, value)) try: rating = Rating.objects.get(user=user, item=item) rating.value = value except (Rating.DoesNotExist): rating = Rating(user=user, item=item, value=value) rating.save()
def get_rating(apps, schema_editor): rating = apps.get_model("ratings", "Rating") with open('../ml-100k/u.data', 'r') as f: data = csv.reader(f, delimiter='\t') for row in data: rater = Rater.objects.get(id=row[0]) movie = Movie.objects.get(id=row[1]) rating = Rating(rater=rater, movie=movie, rating=row[2]) rating.save()
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 rateItem(request, item_id): item = get_object_or_404(Item, pk=item_id) value = request.POST['value'] user = request.user # Update the rating if it exists, otherwise create it try: rating = Rating.objects.get( user=user, item=item ) rating.value = value except (Rating.DoesNotExist): rating = Rating( user=user, item=item, value=value ) rating.save() return HttpResponseRedirect(reverse('ratings:viewItem', args=(item.id, )))
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 do_rating(self, user_from, rating, comment=None): self.check_user_can_rate(user_from) relation_type, user = self.target_rating(user_from) category = settings.RATINGS_STEP_FEEDBACK Rating.update( rating_context=self, rating_object=user, user=user_from, rating=rating, category=category, comment=comment, ) signal_post_overall_rating_team_step_save.send( sender=self.__class__, team_step=self, user=user, relation_type=relation_type) return rating
def test_rating_recipe_calculate_account_stars(self, api_client): first_recipe = RecipeFactory() recipe_author = first_recipe.author api_client.force_authenticate(recipe_author) second_recipe = RecipeFactory.build() data = { 'title': {second_recipe.title}, 'description': {second_recipe.description}, 'flavor_type': {second_recipe.flavor_type}, } api_client.post(create_recipe_url, data) second_recipe = Recipe.objects.all().get(title=second_recipe.title) data = { 'recipe': first_recipe.id, 'stars': 5 } api_client.post(rating_rate_url, data) data = { 'recipe': second_recipe.id, 'stars': 0 } api_client.post(rating_rate_url, data) api_client.logout() second_user = UserFactory() api_client.force_authenticate(second_user) data = { 'recipe': first_recipe.id, 'stars': 5 } api_client.post(rating_rate_url, data) data = { 'recipe': second_recipe.id, 'stars': 5 } api_client.post(rating_rate_url, data) api_client.logout() first_recipe = Recipe.objects.all().get(title=first_recipe.title) second_recipe = Recipe.objects.all().get(title=second_recipe.title) user = UserAccount.objects.all().get(id=recipe_author.id) assert first_recipe.stars == '5.0' assert second_recipe.stars == '2.5' assert Rating.get_account_stars_score(user=user) == 3.75 assert user.stars == '3.75'
def calculate_scores_for_all_options(event, poll): options = Option.objects.filter(poll=poll) return_dict = {"poll": poll, "event": event} if Rating.objects.filter(poll=poll): return_dict["raters"] = Rating.number_of_raters(poll) return_dict["categories"] = Category.objects.filter(poll=poll) return_dict["options"] = [] for option in options: scores = calculate_scores_for_single_option(poll, option) return_dict["options"].append({"title": option.title, "scores": scores[0], "final_score": scores[1]}) else: return_dict["no_ratings"] = True return return_dict
def get_new_ratings(self, game, ranks): new_ratings = [] for rank in ranks: player_rating = self.get_player_game_rating(game, rank) opponent_ranks = ranks.exclude(player=rank.player) opponent_ratings = [ self.get_player_game_rating(game, opponent_rank) for opponent_rank in opponent_ranks ] new_ratings.append( (rank.player, player_rating[1] + sum(Rating.get_adjustments(player_rating, opponent_ratings))) ) return new_ratings
def do_rating(self, user_from, rating, comment=None): from ..tasks import PostAnswerRatingTask act_action.send( user_from, verb=settings.FORUM_ACTION_RATING_POST, action_object=self) category = settings.RATINGS_ANSWER_ADVISOR Rating.update( rating_context=self, rating_object=self, user=user_from, rating=rating, category=category, comment=comment, ) signal_post_overall_rating_answer_save.send( sender=self.__class__, answer=self) new_action_answer.send( sender=self.__class__, instance=self, action=settings.FORUM_ACTION_RATING_POST, ) kwargs = {} kwargs['eta'] = increase_date(seconds=settings.FORUM_NEW_POST_DELAY) PostAnswerRatingTask().s( answer_pk=self.pk, rating=rating, ).apply_async(**kwargs) return rating
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 test_get_recipe_avg_rating_score(api_client): new_recipe = RecipeFactory() api_client.force_authenticate(new_recipe.author) new_recipe = Recipe.objects.all().get(id__exact=new_recipe.id) data = {'recipe': new_recipe.id, 'stars': 5} api_client.post(rating_create_url, data) api_client.logout() new_user = UserFactory() api_client.force_authenticate(new_user) data = {'recipe': new_recipe.id, 'stars': 1} api_client.post(rating_create_url, data) recipe_avg_stars = Rating.get_recipe_stars_score(recipe=new_recipe) assert recipe_avg_stars == 3.0
def test_get_account_stars_score(api_client): user = UserFactory() api_client.force_authenticate(user) first_recipe = RecipeFactory.build() create_recipe_url = reverse('recipes:create') data = { 'title': {first_recipe.title}, 'description': {first_recipe.description}, 'flavor_type': {first_recipe.flavor_type}, } api_client.post(create_recipe_url, data) second_recipe = RecipeFactory.build() data = { 'title': {second_recipe.title}, 'description': {second_recipe.description}, 'flavor_type': {second_recipe.flavor_type}, } api_client.post(create_recipe_url, data) first_recipe = Recipe.objects.all().get(title__exact=first_recipe.title) data = {'recipe': first_recipe.id, 'stars': 5} api_client.post(rating_create_url, data) second_recipe = Recipe.objects.all().get(title__exact=second_recipe.title) data = {'recipe': second_recipe.id, 'stars': 0} api_client.post(rating_create_url, data) second_user = UserFactory() api_client.force_authenticate(second_user) data = {'recipe': first_recipe.id, 'stars': 1} api_client.post(rating_create_url, data) data = {'recipe': second_recipe.id, 'stars': 3} api_client.post(rating_create_url, data) account_avg_stars = Rating.get_account_stars_score(user=user) assert account_avg_stars == 2.25
def test_rating_recipe_calculate_recipe_stars(self, api_client): recipe = RecipeFactory() first_user = UserFactory() api_client.force_authenticate(first_user) data = { 'recipe': recipe.id, 'stars': 4 } api_client.post(rating_rate_url, data) api_client.logout() second_user = UserFactory() api_client.force_authenticate(second_user) data = { 'recipe': recipe.id, 'stars': 2 } api_client.post(rating_rate_url, data) recipe = Recipe.objects.all().get(id=recipe.id) assert recipe.stars == '3.0' assert recipe.stars == str(Rating.get_recipe_stars_score(recipe=recipe))
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)
def test_get_search_url(): assert Rating.get_search_url() == reverse('ratings:search')
def test_get_create_url(): assert Rating.get_create_url() == reverse('ratings:create')
import pytest from django.urls import reverse from factories import RatingFactory, RecipeFactory, UserFactory from ratings.models import Rating from recipes.models import Recipe pytestmark = pytest.mark.django_db rating_create_url = Rating.get_create_url() def test__str__(): new_rating = RatingFactory() assert new_rating.__str__() == str(new_rating.author) def test_get_delete_url(): new_rating = RatingFactory() assert new_rating.get_delete_url() == reverse('ratings:delete', kwargs={"pk": new_rating.id}) def test_get_create_url(): assert Rating.get_create_url() == reverse('ratings:create') def test_get_search_url(): assert Rating.get_search_url() == reverse('ratings:search')
# TODO add tests for MIN and MAX values of stars # TODO test perform_create import pytest from django.urls import reverse from accounts.models import UserAccount from factories import RatingFactory, RecipeFactory, UserFactory from ratings.models import Rating from recipes.models import Recipe pytestmark = pytest.mark.django_db rating_rate_url = Rating.get_create_url() rating_search_url = Rating.get_search_url() create_recipe_url = Recipe.get_create_url() class TestRatingCreateView: class TestAuthenticatedUsers: def test_rating_page_render(self, api_client): new_user = UserFactory() api_client.force_authenticate(new_user) response = api_client.get(rating_rate_url) assert response.status_code == 405 def test_rate_post_request(self, api_client): new_user = UserFactory() api_client.force_authenticate(new_user) new_recipe = RecipeFactory() new_recipe = Recipe.objects.all().get(id__exact=new_recipe.id)
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)
s.day = date s.location = Location.objects.get(pk=loc) s.save() for i, (k, v) in enumerate(d.iteritems(), 1): if s.pk in v: s.paper.add(Paper.objects.get(pk=i)) s.save() f.close() ## ratings f = open('/Users/dimitriosalikaniotis/Sites/llc/llc_site/llc/utils/ratings.txt') for line in f: r = Rating() try: pid = line.strip().split('\t')[0] r.paper = Paper.objects.get(pk=pid) except: pass try: rid = line.strip().split('\t')[1] if rid != "None": r.rater = Participant.objects.get(pk=rid) except: pass try: r.score = float(line.strip().split('\t')[2]) except: pass
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")
# {{{ 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 ])