def get(self, request, *args, **kwargs):
activate_language(request.session)
if request.user.is_authenticated:
if 'team' in request.session:
team = Team.objects.filter(pk=request.session['team']).first()
else:
team = TeamRelationToUser.objects.get(user=request.user).team
competition = Competition.objects.get(pk=kwargs['pk'])
if competition.canTeamRegister(team, request.user) == -1:
CompetitionTeam.objects.filter(
team=team, competition=competition).delete()
for rel in TeamRelationToUser.objects.filter(team=team).all():
for distance in Distance.objects.filter(
competition=competition).all():
UserDistance.objects.filter(
user=rel.user, distance=distance).delete()
delete_badge(rel.user, competition)
request.session['alerts'] = [{
'type':
'success',
'message':
_('Your team has been unregistrated successful!')
}]
return redirect('/')
def post(self, request, *args, **kwargs):
activate_language(request.session)
if not request.user.is_authenticated:
return redirect('/')
competition = Competition.objects.get(pk=kwargs['pk'])
user = get_object_or_404(User, pk=kwargs['user_id'])
distances = Distance.objects.filter(competition=competition)
data = request.POST
for distance in distances:
try:
user_distance = get_object_or_404(UserDistance,
user=user,
distance=distance)
if data['time_{}'.format(distance.id)]:
user_distance.pre_time = get_time_int(
data['time_{}'.format(distance.id)])
user_distance.save()
else:
user_distance.delete()
except Http404:
if data['time_{}'.format(distance.id)]:
UserDistance.objects.create(user=user,
distance=distance,
pre_time=get_time_int(
data['time_{}'.format(
distance.id)]),
is_finished=True)
return redirect('/competition/{}/user/distances/{}'.format(
competition.pk, user.pk))
def get(self, request, *args, **kwargs):
activate_language(request.session)
competition = Competition.objects.get(pk=kwargs['comp'])
if request.user.is_authenticated and (
request.user.is_admin or request.user.id == int(kwargs['pk'])
or competition.created_by == request.user.id):
try:
user = User.objects.get(pk=kwargs['pk'])
badge_path = getBadge(user, competition)
file_wrapper = FileWrapper(open(badge_path, 'rb'))
file_mimetype = mimetypes.guess_type(badge_path)
response = HttpResponse(file_wrapper,
content_type=file_mimetype)
response['X-Sendfile'] = badge_path
response['Content-Length'] = os.stat(badge_path).st_size
response[
'Content-Disposition'] = 'attachment; filename={}'.format(
'{}\'s_badge.png'.format(
cyrtranslit.to_latin(
remove_ukrainian(user.get_full_name()), 'ru')))
return response
except Exception as ex:
pass
raise Http404
def post(self, request):
activate_language(request.session)
if request.POST['psw'] == request.POST['psw-repeat']:
try:
get_object_or_404(User, email=request.POST['email'])
request.session['alerts'] = [{'type': 'error', 'message': _('User with this email is already exist.')}]
return render(request, self.template_name, get_session_attributes(request))
except Http404:
pass
user = User.objects.create_user(request.POST['email'],
request.POST['first_name'],
request.POST['last_name'],
request.POST['psw'],
)
Profile.objects.create(user=user, city=request.POST['city'])
# if not settings.DEBUG:
# with open(settings.BASE_DIR + '/auth_main/templates/email/email_confirm_{}.html'.format(translation.get_language())) as file:
# link = request.build_absolute_uri() + '/verificate/' + user.profile.verification_code
# send_mail('Q-ORCA email confirm', '',
# settings.EMAIL_HOST_USER,
# [user.email, ], fail_silently=settings.DEBUG,
# html_message=file.read().replace('{link}', link))
# else:
user.profile.is_verificated = True
user.profile.save()
# request.session['alerts'] = [{'type': 'success', 'message': _('We have sent verification link to your email. Please, follow it to verificate your email. If there is no letter, please check "spam" in your email.')}]
return redirect('/')
request.session['alerts'] = [{'type': 'error', 'message': _('Passwords are not equal each other.')}]
return render(request, self.template_name, get_session_attributes(request))
def get(self, request, *args, **kwargs):
activate_language(request.session)
opt = {}
day = int(kwargs['day'])
if day not in [1, 2]:
raise Http404
if request.user.is_authenticated and request.user.profile.role == 2:
competition = get_object_or_404(Competition, id=kwargs['pk'])
if competition.created_by == request.user.id or request.user.is_admin:
users_distances, last_swim = get_swim_params(
int(kwargs['swim']), competition, day)
opt['users_distances'] = users_distances
opt['distance'] = users_distances[0].distance
opt['swim_n'] = kwargs['swim']
opt['day'] = _('Day {}'.format(day))
opt['day_n'] = day
opt['is_next_day'] = competition.count_days > day
opt['is_prev_day'] = day > 1
opt['is_next'] = last_swim > int(kwargs['swim'])
opt['is_prev'] = int(kwargs['swim']) - 1 != 0
opt['competition'] = competition
return render(request, self.template_name,
dict(opt, **get_session_attributes(request)))
raise Http404
def post(self, request, *args, **kwargs):
activate_language(request.session)
if not request.user.is_authenticated or request.user.profile.role == 1:
raise Http404
if int(kwargs['day']) not in [1, 2]:
raise Http404
competition = get_object_or_404(Competition, pk=kwargs['pk'])
if competition.is_creating_finished:
raise Http404
for i in range(10):
if request.POST['length_' + str(i)]:
Distance.objects.create(competition=competition,
type=request.POST['type_' + str(i)],
length=request.POST['length_' +
str(i)],
day=kwargs['day'])
else:
break
if int(kwargs['day']) != competition.count_days:
return redirect('/core/competition/{}/create/day/2'.format(
competition.pk))
else:
competition.is_creating_finished = True
competition.save()
return redirect('/core/competition/{}'.format(competition.pk))
def post(self, request, *args, **kwargs):
activate_language(request.session)
if not request.user.is_authenticated:
return redirect('/')
competition = Competition.objects.get(pk=kwargs['pk'])
if competition.canUserRegister(request.user) == 1:
for x in range(10):
time_name = 'time_{}'.format(x)
if time_name in request.POST:
if request.POST[time_name]:
try:
time = get_time_int(request.POST[time_name])
except ValueError:
request.session['alerts'] = [{
'type':
'error',
'message':
_('Wrong time format')
}]
return redirect('/core/competition/{}'.format(
competition.pk))
distance = Distance.objects.get(
pk=request.POST['distance_id_{}'.format(x)])
UserDistance.objects.create(
distance=distance,
user=request.user,
pre_time=time,
result_time=None,
)
if int(kwargs['rel']) == 0:
obj = CompetitionUser.objects.create(user=request.user,
competition=competition)
else:
obj = get_object_or_404(CompetitionUser, pk=kwargs['rel'])
else:
request.session['alerts'] = [{
'type':
'error',
'message':
_('You have been already registrated on this competition!')
}]
return redirect('/core/competition/{}'.format(competition.pk))
if int(kwargs['day']) != competition.count_days:
return redirect('/core/competition/{}/signup/single/2/{}'.format(
competition.pk, obj.pk))
else:
obj.is_complete = True
obj.save()
getBadge(request.user, competition)
request.session['alerts'] = [{
'type':
'success',
'message':
_('You have been registrated successful!')
}]
return redirect('/core/competition/{}'.format(competition.pk))
def get(self, request, *args, **kwargs):
activate_language(request.session)
if 'team' in request.session:
return redirect('/core/teams/{}'.format(
request.session['team'].name))
opt = {}
return render(request, self.template_name,
dict(opt, **get_session_attributes(request)))
def get(self, request, *args, **kwargs):
activate_language(request.session)
opt = get_session_attributes(request)
try:
next = request.environ['QUERY_STRING'].split('=')[1]
if next:
request.session['next'] = next
except:
pass
return render(request, self.template_name, opt)
def post(self, request, *args, **kwargs):
activate_language(request.session)
ContactMessage.objects.create(
full_name=request.POST['name'],
email=request.POST['email'],
message=request.POST['message'],
)
request.session['alerts'] = [
{'type': 'success', 'message': _('We will read your message as soon as possible.')}]
return redirect('/')
def get(self, request, *args, **kwargs):
activate_language(request.session)
if not request.user.is_authenticated:
return redirect('/')
competition = get_object_or_404(Competition, pk=kwargs['pk'])
if int(kwargs['day']) not in [1, 2]:
raise Http404
if not competition.is_creating_finished:
raise Http404
if 'team' in request.session:
team = Team.objects.filter(pk=request.session['team']).first()
else:
team = TeamRelationToUser.objects.get(user=request.user).team
if competition.canTeamRegister(team, request.user) == 1:
users_without_birthdate = ''
for rel in TeamRelationToUser.objects.filter(team=team).all():
if rel.user.profile.birth_date is None:
users_without_birthdate += rel.user.get_full_name() + ', '
if users_without_birthdate:
request.session['alerts'] = [{
'type':
'error',
'message':
users_without_birthdate[:-2] + ' ' +
_('need to fill birth date in profile to register on this competition.'
)
}]
return redirect('/core/competition/{}'.format(competition.pk))
msg = _('Day ') + kwargs['day']
users = TeamRelationToUser.objects.filter(team=team).all()
distances = Distance.objects.filter(competition=competition,
day=kwargs['day']).all()
return render(
request, self.template_name, {
'types': Distance.TYPES,
'distances': distances,
'competition': competition,
'users': users,
'day': msg
})
request.session['alerts'] = [{
'type':
'error',
'message':
_('You cannot register team on this competition')
}]
return redirect('/')
def post(self, request):
activate_language(request.session)
team = Team.objects.create(name=request.POST['name'],
logo=request.FILES['logo'],
description=request.POST['description'])
TeamRelationToUser.objects.create(team=team,
user=request.user,
is_coach=True)
request.session['team'] = team.pk
request.session['alerts'] = [{
'type': 'success',
'message': _('Team has been created!')
}]
return redirect('/core/teams/{}'.format(team.name))
def get(self, request, *args, **kwargs):
activate_language(request.session)
team = Team.objects.get(name=kwargs['name'])
team_rel_users = TeamRelationToUser.objects.filter(team=team)
is_coach = team_rel_users.filter(user=request.user).first().is_coach
competitions_count = CompetitionTeam.objects.filter(team=team).count()
opt = {
'curr_team': team,
'team_rel_users': team_rel_users,
'is_coach': is_coach,
'competitions': competitions_count,
}
return render(request, self.template_name,
dict(opt, **get_session_attributes(request)))
def post(self, request):
activate_language(request.session)
data = json.loads(request.body.decode('utf-8'))
team = Team.objects.get(name=data['team_name'])
inv = Invitations.objects.filter(to_user=request.user,
team=team,
is_active=True)
if inv.exists():
inv = inv.first()
else:
return HttpResponse(status=400)
inv.is_active = False
inv.save()
return HttpResponse(status=200)
def get(self, request, *args, **kwargs):
activate_language(request.session)
user_list = User.objects.order_by('-created_at')
paginator = Paginator(user_list, 20)
page = request.GET.get('page', 1)
try:
users = paginator.page(page)
except PageNotAnInteger:
users = paginator.page(1)
except EmptyPage:
users = paginator.page(paginator.num_pages)
opt = {'users': users}
return render(request, self.template_name,
dict(opt, **get_session_attributes(request)))
def main(request, *args, **kwargs):
activate_language(request.session)
competitions = Competition.getLastCompetitions()
opt = dict()
opt['competitions'] = competitions
if request.user.is_authenticated:
opt.update({
'gender':
_('male') if request.user.profile.gender == 1 else _('female')
})
request.user.profile.get_age_group()
return render(request, 'core/index.html',
dict(opt, **get_session_attributes(request)))
else:
return render(request, 'core/index.html',
dict(opt, **get_session_attributes(request)))
def get(self, request, *args, **kwargs):
activate_language(request.session)
if request.user.is_authenticated:
teams_rel_user = None
try:
teams_rel_user = TeamRelationToUser.objects.filter(user=request.user)
except:
pass
invitations = Invitations.objects.filter(to_user=request.user, is_active=True).order_by('-created_at')
opt = {'user': request.user,
'teams_rel_user': teams_rel_user,
'invitations': invitations}
return render(request, self.template_name, dict(opt, **get_session_attributes(request)))
else:
return redirect('/auth/login')
def post(self, request):
activate_language(request.session)
data = json.loads(request.body.decode('utf-8'))
search = data['search'].strip()
if ' ' in search:
search = search.split(' ')
query = Q()
for x in search:
query = query | (Q(first_name__contains=x)
| Q(last_name__contains=x))
users = User.objects.filter(query).all()
else:
users = User.objects.filter(
Q(first_name__contains=search)
| Q(last_name__contains=search)).all()
users_json = json.dumps(queryset_to_dict(users))
return HttpResponse(users_json)
def get(self, request, *args, **kwargs):
activate_language(request.session)
if not request.user.is_authenticated:
return redirect('/')
competition = get_object_or_404(Competition, pk=kwargs['pk'])
if int(kwargs['day']) not in [1, 2]:
raise Http404
if not competition.is_creating_finished:
raise Http404
if competition.canUserRegister(request.user) == 1:
if request.user.profile.birth_date is None:
request.session['alerts'] = [{
'type':
'error',
'message':
_('You need to fill your birth date in profile to register on competition'
)
}]
return redirect('/core/competition/{}'.format(competition.pk))
if int(kwargs['day']) == 1:
UserDistance.objects.filter(distance__competition=competition,
user=request.user).delete()
CompetitionUser.objects.filter(competition=competition,
user=request.user).delete()
distances = Distance.objects.filter(competition=competition,
day=kwargs['day']).all()
msg = _('Day ') + kwargs['day']
return render(
request, self.template_name, {
'types': Distance.TYPES,
'distances': distances,
'competition': competition,
'day': msg,
'rel': kwargs['rel']
})
request.session['alerts'] = [{
'type':
'error',
'message':
_('You cannot register on this competition')
}]
return redirect('/')
def post(self, request):
activate_language(request.session)
if request.user.is_authenticated:
if 'city' in request.POST:
data = dict()
for x in request.POST:
data[x] = request.POST[x]
try:
request.user.profile.update_data(**data)
except ValueError:
opt = {'error': _('Wrong date format')}
return render(request, self.template_name, dict(opt, **get_session_attributes(request)))
return redirect('/auth/profile')
else:
request.user.profile.avatar = request.FILES['img']
request.user.profile.save()
return HttpResponse()
def post(self, request, *args, **kwargs):
activate_language(request.session)
data = json.loads(request.body.decode('utf-8'))
search = data['search'].strip()
competition = get_object_or_404(Competition, pk=kwargs['pk'])
if ' ' in search:
search = search.split(' ')
query = Q()
for x in search:
query = query | (Q(user__first_name__contains=x)
| Q(user__last_name__contains=x))
users = UserDistance.objects.filter(distance__competition=competition).filter(query).\
values('user').distinct()[:10]
else:
users = UserDistance.objects.filter(distance__competition=competition).filter(Q(user__first_name__contains=search) | Q(user__last_name__contains=search))\
.values('user').distinct()[:10]
users_json = json.dumps(querysetdistance_to_dict(users, competition))
return HttpResponse(users_json)
def post(self, request):
if not request.user.is_authenticated or request.user.profile.role == 1:
raise Http404
activate_language(request.session)
competition = Competition.objects.create(
name=request.POST['name'],
description=request.POST['description'],
logo=request.FILES['logo'],
region=request.POST['region'],
track_count=request.POST['track_count'],
count_days=request.POST['count_days'],
started_at=datetime.datetime.strptime(request.POST['started_at'],
"%Y-%m-%d").date(),
created_by=request.user,
)
return redirect('/core/competition/{}/create/day/1'.format(
competition.pk))
def post(self, request, *args, **kwargs):
activate_language(request.session)
day = int(kwargs['day'])
if day not in [1, 2]:
raise Http404
if request.user.is_authenticated and request.user.profile.role == 2:
competition = get_object_or_404(Competition, id=kwargs['pk'])
if competition.created_by == request.user.id or request.user.is_admin:
for attr in request.POST:
if 'result' not in attr:
continue
user_distance_id = int(attr.split('_')[-1])
if is_correct_time(request.POST[attr]):
user_distance = UserDistance.objects.filter(
id=user_distance_id).first()
user_distance.result_time = request.POST[attr]
user_distance.points = get_points(
user_distance.distance, user_distance.user,
request.POST[attr], day, competition)
print(user_distance.points)
user_distance.save()
else:
request.session['alerts'] = [{
'type': 'error',
'message':
_('%(user)s result time has wrong format. Please try again.'
) %
{
'user':
UserDistance.objects.filter(
id=user_distance_id).first().user.full_name
}
}]
if 'alerts' not in request.session:
request.session['alerts'] = [{
'type': 'success',
'message': _('Success!')
}]
return redirect('/competition/{}/swim/{}/day/{}'.format(
competition.pk, kwargs['swim'], day))
raise Http404
def get(self, request, *args, **kwargs):
activate_language(request.session)
competition = Competition.objects.get(pk=kwargs['comp'])
if request.user.is_authenticated and request.user.profile.role == 2:
if competition.created_by == request.user.id or request.user.is_admin:
badge_path = get_all_badges(competition)
file_wrapper = FileWrapper(open(badge_path, 'rb'))
file_mimetype = mimetypes.guess_type(badge_path)
response = HttpResponse(file_wrapper,
content_type=file_mimetype)
response['X-Sendfile'] = badge_path
response['Content-Length'] = os.stat(badge_path).st_size
response[
'Content-Disposition'] = 'attachment; filename={}'.format(
'badges.zip')
return response
raise Http404
def get(self, request, *args, **kwargs):
if not request.user.is_authenticated or request.user.profile.role == 1:
raise Http404
if int(kwargs['day']) not in [1, 2]:
raise Http404
competition = get_object_or_404(Competition, pk=kwargs['pk'])
if competition.is_creating_finished:
raise Http404
activate_language(request.session)
msg = _('Day ') + kwargs['day']
return render(
request, self.template_name, {
'types': Distance.TYPES,
'range': range(10),
'day': msg,
'is_first_day': int(kwargs['day']) == 1
})
def get(self, request, *args, **kwargs):
activate_language(request.session)
if not request.user.is_authenticated:
return redirect('/')
competition = get_object_or_404(Competition, pk=kwargs['pk'])
user = get_object_or_404(User, pk=kwargs['user_id'])
distances = Distance.objects.filter(competition=competition).all()
ret_1 = []
ret_2 = []
is_day_2 = False
for distance in distances:
if distance.day == 2:
is_day_2 = True
user_distance = UserDistance.objects.filter(
user=user, distance=distance).first()
temp = {'distance': distance}
if user_distance:
temp['time'] = time_to_str(user_distance.pre_time)
else:
temp['time'] = ''
ret_2.append(temp)
else:
user_distance = UserDistance.objects.filter(
user=user, distance=distance).first()
temp = {'distance': distance}
if user_distance:
temp['time'] = time_to_str(user_distance.pre_time)
else:
temp['time'] = ''
ret_1.append(temp)
return render(
request, self.template_name, {
'types': Distance.TYPES,
'competition': competition,
'ret_1': ret_1,
'ret_2': ret_2,
'curr_user': user,
'is_day_2': is_day_2
})
def get(self, request, *args, **kwargs):
activate_language(request.session)
if request.user.is_authenticated:
competition = Competition.objects.get(pk=kwargs['pk'])
if competition.canUserRegister(request.user) == -1:
CompetitionUser.objects.filter(
user=request.user, competition=competition).delete()
for distance in Distance.objects.filter(
competition=competition).all():
UserDistance.objects.filter(user=request.user,
distance=distance).delete()
delete_badge(request.user, competition)
request.session['alerts'] = [{
'type':
'success',
'message':
_('You have been unregistrated successful!')
}]
return redirect('/')
def post(self, request):
activate_language(request.session)
user = authenticate(email=request.POST['email'], password=request.POST['psw'])
if user is not None:
if not user.profile.is_verificated:
request.session['alerts'] = [{'type': 'error', 'message': _('Please verificate your email to log in.')}]
return redirect('/auth/verification/reset')
login(request, user)
try:
request.session['team'] = get_object_or_404(TeamRelationToUser, user=request.user).team.pk
except Http404:
pass
if 'next' in request.session:
del request.session['next']
return redirect(request.session['next'])
return redirect('/')
return redirect('/auth/login')
def get(self, request, *args, **kwargs):
activate_language(request.session)
if request.user.is_authenticated and request.user.profile.role == 2:
competition = get_object_or_404(Competition, id=kwargs['pk'])
if competition.created_by == request.user.id or request.user.is_admin:
path = ResultsExcel(competition).create_rating()
if path is None:
return
file_wrapper = FileWrapper(open(path, 'rb'))
file_mimetype = mimetypes.guess_type(path)
response = HttpResponse(file_wrapper,
content_type=file_mimetype)
response['X-Sendfile'] = path
response['Content-Length'] = os.stat(path).st_size
response[
'Content-Disposition'] = 'attachment; filename={}'.format(
'rating.xlsx')
return response
raise Http404
return redirect('/auth/login')
def post(self, request):
activate_language(request.session)
data = json.loads(request.body.decode('utf-8'))
team = Team.objects.get(name=data['team_name'])
try:
get_object_or_404(TeamRelationToUser, user=request.user)
return HttpResponse(status=401)
except Http404:
pass
TeamRelationToUser.objects.get_or_create(user=request.user, team=team)
inv = Invitations.objects.filter(to_user=request.user,
team=team,
is_active=True)
if inv.exists():
inv = inv.first()
else:
return HttpResponse(status=400)
inv.is_active = False
inv.save()
request.session['team'] = team.pk
return HttpResponse(status=200)
