def search_by_id(request, id=None):
context = {}
phone_number = None
if id is None:
id = request.GET.get("id_for_search", '').strip()
if id == '':
return redirect("results:races")
elif models.is_phone_number_correct(id):
phone_number = ''.join(c for c in id if c.isdigit())[-7:]
id = None
elif models.int_safe(id) > 0:
id = models.int_safe(id)
# elif (id[0] in u'MmМмWw') and (models.int_safe(id[1:]) > 0):
# runner = models.Runner.objects.filter(ak_person_id=id).first()
# if runner:
# return redirect(runner)
# else:
# return redirect("results:runners")
# elif models.Event.objects.filter(ak_race_id=id).exists():
# return redirect("results:event_details", ak_race_id=id)
else:
return redirect("results:races", race_name=id)
if id:
context['page_title'] = u'Объекты с id={}'.format(id)
context['id'] = id
context['series'] = models.Series.objects.filter(pk=id).first()
context['event'] = models.Event.objects.filter(pk=id).first()
context['race'] = models.Race.objects.filter(pk=id).first()
context['news'] = models.News.objects.filter(pk=id).first()
# context['runner'] = User.objects.filter(pk=id).first() # TODO
context['city'] = models.City.objects.filter(pk=id).first()
context['document'] = models.Document.objects.filter(pk=id).first()
context['distance'] = models.Distance.objects.filter(pk=id).first()
context['club'] = models.Club.objects.filter(pk=id).first()
context['klb_person'] = models.Klb_person.objects.filter(pk=id).first()
context['klb_team'] = models.Klb_team.objects.filter(pk=id).first()
context['user'] = User.objects.filter(pk=id).first()
context['user_profile'] = models.User_profile.objects.filter(
pk=id).first()
context['runner'] = models.Runner.objects.filter(pk=id).first()
context['table_update'] = models.Table_update.objects.filter(
pk=id).first()
context['result'] = models.Result.objects.filter(pk=id).first()
context['klb_participant'] = models.Klb_participant.objects.filter(
pk=id).first()
context['klb_result'] = models.Klb_result.objects.filter(pk=id).first()
context['club_member'] = models.Club_member.objects.filter(
pk=id).first()
elif phone_number:
context[
'page_title'] = u'Участники КЛБМатчей с телефонами, содержащими {}'.format(
phone_number)
context['phone_number'] = phone_number
context[
'participants_with_phone_number'] = models.Klb_participant.objects.filter(
phone_number_clean__contains=phone_number).select_related(
'team__club',
'klb_person').order_by('match_year', 'klb_person__lname',
'klb_person__fname')
return render(request, "editor/search_by_id.html", context)
def claim_results(request):
results_claimed = 0
results_errors = 0
runner_id = models.int_safe(request.POST.get('select_runner', 0))
runner = models.Runner.objects.filter(pk=runner_id).first()
if runner is None:
return 0, None
for key, val in request.POST.items():
if key.startswith("claim_"):
result_id = models.int_safe(key[len("claim_"):])
result = models.Result.objects.filter(id=result_id,
runner=None).first()
if result:
res, msgError = result.claim_for_runner(
request.user,
runner,
comment=u'Со страницы всех результатов')
if res:
results_claimed += 1
if result.place_gender == 1:
result.race.fill_winners_info()
else:
results_errors += 1
if msgError:
messages.warning(request, msgError)
if results_claimed:
update_runner_stat(runner=runner)
if runner.user:
update_runner_stat(user=runner.user, update_club_members=False)
return results_claimed, runner
def loaded_protocols_by_month(request):
context = {}
month_ago = datetime.date.today() - datetime.timedelta(days=28)
month = month_ago.month
year = month_ago.year
if request.method == 'POST':
form = forms.MonthYearForm(request.POST)
if form.is_valid():
month = models.int_safe(form.cleaned_data['month'])
year = models.int_safe(form.cleaned_data['year'])
else:
form = forms.MonthYearForm(initial={'month': month, 'year': year})
date_from = datetime.date(year, month, 1)
date_to = datetime.date(year, month, monthrange(year, month)[1])
table_updates = models.Table_update.objects.filter(
action_type=models.ACTION_RESULTS_LOAD,
added_time__gte=date_from,
added_time__lte=date_to)
race_ids = set(table_updates.values_list('child_id', flat=True))
race_by_id = {}
for race in models.Race.objects.filter(pk__in=race_ids).annotate(
Count('result')).select_related(
'event__series__city__region__country',
'event__city__region__country'):
race_by_id[race.id] = race
context['races'] = []
events_used = set()
races_used = set()
context['n_results'] = 0
for update in table_updates.order_by('-added_time'):
# We take only still existing racec, and we take only the latest results loading for each race in current month
if (update.child_id in race_by_id) and (update.child_id
not in races_used):
race = race_by_id[update.child_id]
context['races'].append((race, update))
races_used.add(update.child_id)
events_used.add(race.event_id)
context['n_results'] += race.result__count
context['page_title'] = u'Все обработанные протоколы за {} {}'.format(
forms.MONTHS[month - 1][1], year)
context['site_url'] = models.SITE_URL
context['form'] = form
context['n_events'] = len(events_used)
context['n_races'] = len(races_used)
return render(request, "editor/loaded_protocols_by_month.html", context)
def result_add_to_klb(request, result_id):
result = get_object_or_404(models.Result, pk=result_id)
year = result.race.event.start_date.year
if ('select_participant_for_klb' in request.POST) and (result.get_klb_status() == models.KLB_STATUS_OK):
participant_id = models.int_safe(request.POST['select_participant_for_klb'])
participant = get_object_or_404(models.Klb_participant, pk=participant_id, match_year=year)
person = participant.klb_person
if participant.match_year != year:
messages.warning(request, u'Результат относится к {} году, а участник — к {} году'.format(year, participant.match_year))
if result.race.klb_result_set.filter(klb_person=person).exists():
messages.warning(request, u'У участника КЛБМатчей с id {} уже есть результат в матче на этом старте'.format(person_id))
else:
only_bonus_score = 'only_bonus_score' in request.POST
team = participant.team if participant else None
klb_result = create_klb_result(result, person, request.user, only_bonus_score=only_bonus_score, comment=u'Со страницы правки результата')
update_persons_score(year=year, persons_to_update=[person])
if team:
prev_score = team.score
team.refresh_from_db()
models.Klb_team_score_change.objects.create(
team=team,
race=result.race,
clean_sum=team.score - team.bonus_score,
bonus_sum=team.bonus_score,
delta=team.score - prev_score,
n_persons_touched=1,
comment=u'Добавление результата участника {} {}{}'.format(person.fname, person.lname, u' (только бонусы)' if only_bonus_score else ''),
added_by=request.user,
)
messages.success(request, u'Результат успешно засчитан в КЛБМатч. Очки участника {} {} (id {}) обновлены'.format(
person.fname, person.lname, person.id))
return redirect(result.get_editor_url())
def add_series(request, organizer_id):
organizer = get_object_or_404(models.Organizer, pk=organizer_id)
if 'select_series' in request.POST:
series_id = models.int_safe(request.POST['select_series'])
series = get_object_or_404(models.Series, pk=series_id)
if series.organizer_id != models.FAKE_ORGANIZER_ID:
messages.warning(request, u'У серии {} (id {}) уже указан организатор {} (id {}).'.format(
series.name, series_id, series.organizer.name, series.organizer.id))
else:
log = logging.getLogger('structure_modification')
log_prefix = 'add_series {} to organizer {} by user {}.'.format(series.id, organizer_id, request.user.id)
log.debug('{} before flock'.format(log_prefix))
log_exc_info = False
with Flock_mutex(LOCK_FILE_FOR_RATED_TREE_MODIFICATIONS):
log.debug('{} trnsctn start'.format(log_prefix))
try:
with transaction.atomic():
change_parent(series, organizer) # to adapt the starrating data)
series.organizer = organizer
series.save()
models.log_obj_create(request.user, series, models.ACTION_UPDATE, field_list=['organizer'])
log.debug('{} trnsctn end'.format(log_prefix))
except (UpdatedRecordExistsError, AssertionError) as e:
error_msg = repr(e)
if isinstance(e, AssertionError):
log_exc_info = True
else:
error_msg = None
if error_msg is None:
log.info('{} OK'.format(log_prefix))
messages.success(request, u'Серия «{}» (id {}) успешно добавлена этому организатору.'.format(series.name, series_id))
else:
log.error('{} {}'.format(log_prefix, error_msg), exc_info=log_exc_info)
messages.warning(request, u'Не удалось добавить серию «{}» (id {}) этому организатору ({}).'.format(series.name, series_id, error_msg))
return redirect(organizer)
def result_delete_from_klb(request, result_id):
result = get_object_or_404(models.Result, pk=result_id)
if ('frmKlbResult_submit' in request.POST) and hasattr(result, 'klb_result') and \
(result.race.get_klb_status() in (models.KLB_STATUS_OK, models.KLB_STATUS_ONLY_ONE_PARTICIPANT)):
person_id = models.int_safe(request.POST.get('select_person_for_klb', 0))
klb_result = result.klb_result
person = klb_result.klb_person
team = klb_result.klb_participant.team
models.log_obj_delete(request.user, result.race.event, child_object=klb_result, action_type=models.ACTION_KLB_RESULT_DELETE)
klb_result.delete()
to_update_runner = False
if 'to_unclaim' in request.POST:
result.unclaim_from_runner(request.user)
to_update_runner = True
update_persons_score(year=result.race.event.start_date.year, persons_to_update=[person], update_runners=to_update_runner)
if team:
prev_score = team.score
team.refresh_from_db()
models.Klb_team_score_change.objects.create(
team=team,
race=result.race,
clean_sum=team.score - team.bonus_score,
bonus_sum=team.bonus_score,
delta=team.score - prev_score,
n_persons_touched=1,
comment=u'Удаление результата участника {} {} из КЛБМатча'.format(person.fname, person.lname),
added_by=request.user,
)
messages.success(request, u'Результат успешно удалён из КЛБМатча. Очки участника {} {} (id {}) обновлены'.format(
person.fname, person.lname, person.id))
return redirect(result.get_editor_url())
return result_details(request, result_id=result_id, result=result)
def get_page_num(request):
page_vals = (request.POST
if request.method == 'POST' else request.GET).getlist('page')
for page_val in page_vals:
if page_val.strip() != '':
return models.int_safe(page_val)
return 1
def events_wo_protocol(request, year):
year = models.int_safe(year)
context = {}
context['year'] = year
context.update(get_year_constants())
context['list_title'] = context[
'page_title'] = u"Завершившиеся пробеги {} года без протоколов".format(
year)
context['frmSearchSeries'] = forms.SeriesSearchForm()
today = datetime.date.today()
cur_year_events = models.Event.objects.filter(
start_date__year=year, start_date__lt=today,
cancelled=False).select_related('series')
event_wo_protocol_ids = set()
series_wo_protocol_ids = set()
for event in cur_year_events:
if not event.document_set.filter(
document_type__in=models.DOC_PROTOCOL_TYPES).exists():
event_wo_protocol_ids.add(event.id)
series_wo_protocol_ids.add(event.series.id)
context['seria'] = models.Series.objects.filter(
id__in=series_wo_protocol_ids).prefetch_related(
Prefetch(
'event_set',
queryset=models.Event.objects.filter(
id__in=event_wo_protocol_ids).order_by('-start_date')))
context['with_events'] = True
return render(request, "editor/seria.html", context)
def klb_make_individual_payment(request, year):
context = user_edit_vars(request.user)
year = models.int_safe(year)
if not models.is_active_klb_year(year, context['is_admin']):
messages.warning(request, u'Сейчас нельзя заявиться в КЛБМатч–{}'.format(year))
return redirect(reverse('results:klb_match_summary', kwargs={'year': year}))
participant = models.Klb_participant.objects.filter(klb_person__runner__user_id=request.user.id, match_year=year).first()
if not participant:
messages.warning(request, u'Вы ещё не заявлены в КЛБМатч–{}'.format(year))
return redirect(reverse('results:klb_application', kwargs={'year': year}))
person = participant.klb_person
if participant.paid_status != models.PAID_STATUS_NO:
messages.warning(request, u'Вы уже оплатили участие в КЛБМатче–{}'.format(year))
return redirect(person)
if participant.team and not participant.team.club.members_can_pay_themselves:
messages.warning(request, u'Ваше участие в КЛБМатче может оплатить только капитан команды «{}»; Вам достаточно передать деньги ему.'.format(
participant.team.name))
return redirect(person)
payment = models.Payment_moneta.objects.create(
amount=models_klb.get_participation_price(year),
description=u'Оплата за себя: {} {}'.format(person.fname, person.lname),
user=request.user,
sender=request.user.get_full_name(),
)
payment.refresh_from_db()
payment.transaction_id = DESCRIPTION_PREFIX + unicode(payment.id)
payment.signature = get_payment_md5(payment)
payment.save()
participant.payment = payment
participant.save()
models.write_log('klb_make_individual_payment: Redirecting to {}'.format(get_redirect_url(payment)))
return redirect(get_redirect_url(payment))
def race_swap_names(request, race_id, swap_type):
race = get_object_or_404(models.Race, pk=race_id)
results = race.result_set.all()
n_touched = 0
swap_type = models.int_safe(swap_type)
for result in results:
if swap_type == 1:
tmp = result.fname
result.fname = result.lname
result.lname = tmp
result.save()
n_touched += 1
elif swap_type == 2:
tmp = result.fname
result.fname = result.midname
result.midname = tmp
result.save()
n_touched += 1
if swap_type in [1,2]:
messages.success(request, u'Успешно обновлено имён: {}.'.format(n_touched))
else:
messages.warning(request, u'Неправильный тип перестановки имён:{}.'.format(swap_type))
if n_touched:
race.fill_winners_info()
return redirect(race)
def klb_person_delete(request, person_id):
person = get_object_or_404(models.Klb_person, pk=person_id)
has_dependent_objects = person.has_dependent_objects()
ok_to_delete = False
form = None
if 'frmForPerson_submit' in request.POST:
if has_dependent_objects:
new_person_id = models.int_safe(request.POST.get('new_person_id'))
if new_person_id:
if new_person_id != person.id:
new_person = models.Klb_person.objects.filter(
pk=new_person_id).first()
if new_person:
success, msg = try_merge_klb_persons_and_runners(
request.user, person, new_person)
if success:
messages.success(
request,
u'Участники КЛБМатчей успешно объединены')
return redirect(new_person)
else:
messages.warning(
request,
u'Не удалось объединить бегунов. Ошибка: {}'.
format(msg))
else:
messages.warning(
request,
u'Бегун, на которого нужно заменить текущего, не найден.'
)
else:
messages.warning(
request,
u'Нельзя заменить участника КЛБМатчей на него же.')
else:
messages.warning(
request,
u'Участник КЛБМатчей, на которого нужно заменить текущего, не указан.'
)
else: # There are no results for person, so we just delete him
ok_to_delete = True
else:
messages.warning(request, u"Вы не указали бегуна для удаления.")
if ok_to_delete:
# if has_dependent_objects:
# update_person(request, person, new_person)
models.log_obj_delete(request.user, person)
runner = person.runner if hasattr(person, 'runner') else None
messages.success(
request, u'Участник КЛБМатчей «{}» успешно удалён.'.format(person))
person.delete()
if has_dependent_objects:
return redirect(new_person)
elif runner:
return redirect(runner)
else:
return redirect('results:klb_match_summary')
return klb_person_details(request, person_id=person_id, person=person)
def events_not_in_match(request, year=0):
year = models.int_safe(year)
if year < 2017:
year = models.CUR_KLB_YEAR
user = request.user
context = user_edit_vars(user)
context['year'] = year
context['page_title'] = u'Забеги, не учитывающиеся в КЛБМатче'
context['events'] = get_events_not_in_klb(year)
return render(request, 'klb/events_not_in_match.html', context)
def about_match(request, year=models.CUR_KLB_YEAR):
year = models.int_safe(year)
context = user_edit_vars(request.user)
if (year < FIRST_YEAR_WITH_INVITATION) or (
(year > models.CUR_KLB_YEAR)
and not models.is_active_klb_year(year, context['is_admin'])):
year = models.CUR_KLB_YEAR
elif year < models.CUR_KLB_YEAR:
context['this_is_old_match'] = True
year_for_results = models.CUR_KLB_YEAR
N_PERSONS_PER_TABLE = 3
teams = models.Klb_team.objects.filter(year=year_for_results).exclude(
number=models.INDIVIDUAL_RUNNERS_CLUB_NUMBER).select_related('club')
if not context['is_admin']:
teams = teams.filter(n_members_started__gt=0)
context['teams_all'] = teams.order_by('place')
context['teams_medium'] = teams.filter(
place_medium_teams__isnull=False).order_by('place_medium_teams')
context['teams_small'] = teams.filter(
place_small_teams__isnull=False).order_by('place_small_teams')
context['groups'] = []
all_participants = models.Klb_participant.objects.filter(
match_year=year_for_results, place__isnull=False)
for group in list(
models.Klb_age_group.get_groups_by_year(year_for_results)):
if group.gender == models.GENDER_UNKNOWN:
participants = all_participants.order_by('place')
elif group.birthyear_min is None:
participants = all_participants.filter(
klb_person__gender=group.gender,
place_gender__isnull=False).order_by('place_gender')
else:
participants = group.klb_participant_set.filter(
place_group__isnull=False).order_by('place_group')
context['groups'].append({
'group':
group,
'participants':
participants.select_related('klb_person__city',
'team')[:N_PERSONS_PER_TABLE]
})
context['page_title'] = u'Приглашение на КЛБМатч–{}'.format(year)
context['year'] = year
context['year_for_results'] = year_for_results
context['small_team_size'] = models_klb.get_small_team_limit(
year_for_results)
context['medium_team_size'] = models_klb.get_medium_team_limit(
year_for_results)
context['regulations_link'] = models_klb.get_regulations_link(year)
context[
'regulations_changes_link'] = models_klb.get_regulations_changes_link(
year)
context['n_results'] = get_stat_value('n_results')
return render(request, 'klb/about_match_{}.html'.format(year), context)
def series_by_letter(request, letter=None):
context = {}
if request.method == 'POST':
saved_series = 0
for key, val in request.POST.items():
if key.startswith('series_'):
series_id = models.int_safe(key[len('series_'):])
series = models.Series.objects.filter(pk=series_id).first()
if series:
new_val = models.int_safe(val)
if series.surface_type != new_val:
series.surface_type = new_val
series.save()
models.log_obj_create(
request.user,
series,
models.ACTION_UPDATE,
field_list=['surface_type'],
comment=u'Массовое проставление типа забега')
saved_series += 1
messages.success(
request,
u'Сохранено значений для серий: {}. Спасибо!'.format(saved_series))
# models.Letter_of_series.objects.filter(letter=letter).update(is_checked=True)
return redirect(
reverse('editor:series_by_letter', kwargs={'letter': letter}))
context['letters'] = models.Letter_of_series.objects.all().order_by(
'letter')
context['surface_types'] = models.SURFACE_TYPES
if letter:
context['page_title'] = u"Все серии на символ {}".format(letter)
context['seria'] = models.Series.objects.filter(
name__istartswith=letter,
series_type=models.SERIES_TYPE_RUN,
surface_type__in=(models.SURFACE_DEFAULT,
models.SURFACE_HARD)).order_by('name')
# context['q'] = models.Series.objects.filter(name__istartswith=letter).order_by('name').query
else:
context[
'page_title'] = u"Заполняем тип забегов у серий. Выберите любую букву"
return render(request, "editor/series_by_letter.html", context)
def winners_by_regions(request, year):
year = models.int_safe(year)
if not (models.FIRST_YEAR_WITH_KLBMATCH_STAT_BY_REGIONS <= year <
models.CUR_KLB_YEAR):
year = models.CUR_KLB_YEAR - 1
context = user_edit_vars(request.user)
context[
'page_title'] = u'КЛБМатч–{}: Итоги по регионам, федеральным округам и странам'.format(
year)
context['template_name'] = 'klb/winners_by_region/{}.html'.format(year)
return render(request, 'results/base_template.html', context)
def all_events_by_year(request, regions=1): # Not for Russia! It is too heavy
context = {}
context.update(get_year_constants())
context['years'] = range(models.NADYA_CALENDAR_YEAR_START,
models.NADYA_CALENDAR_YEAR_END + 1)
regions = models.int_safe(regions)
context['page_title'] = u"Все пробеги {}-{} годов ".format(
models.NADYA_CALENDAR_YEAR_START, models.NADYA_CALENDAR_YEAR_END)
series_ids = set(
models.Event.objects.filter(start_date__year__gte=models.
NADYA_CALENDAR_YEAR_START).values_list(
'series_id', flat=True))
all_series = models.Series.objects.filter(
pk__in=series_ids).select_related('city__region')
# if regions == 0:
# all_series = all_series.filter(city__region__country_id='RU')
# context['page_title'] += u'в России'
if regions == 1:
all_series = all_series.filter(city__region__country_id__in=('UA',
'BY'))
context['page_title'] += u'в Украине и Беларуси'
elif regions == 2:
all_series = all_series.exclude(city__region__country_id__in=('RU',
'UA',
'BY'))
context['page_title'] += u'вне России, Украины, Беларуси'
else:
all_series = all_series.filter(city=None)
context['page_title'] += u'без указания страны'
seria = []
for series in all_series.exclude(
url_site__startswith='http://www.parkrun').exclude(
url_site__startswith='https://www.parkrun').order_by(
'city__region__country__name', 'city__region__name',
'city__name', 'name'):
d = {
'region': series.city.region.name_full
if series.city else 'Регион не указан',
'series': series,
}
# for year in range(models.NADYA_CALENDAR_YEAR_START, models.NADYA_CALENDAR_YEAR_END + 1):
# d['events_{}'.format(year)] = series.event_set.filter(start_date__year=year).order_by('start_date')
events = []
for year in range(models.NADYA_CALENDAR_YEAR_START,
models.NADYA_CALENDAR_YEAR_END + 1):
events.append(
series.event_set.filter(start_date__year=year).select_related(
'series__city__region__country', 'city__region__country',
'series__country').order_by('start_date'))
d['events'] = events
seria.append(d)
context['seria'] = seria
return render(request, "editor/all_events_by_year.html", context)
def klb_team_details(request,
team_id,
show_all_results=False,
ordering=models.ORDERING_CLEAN_SCORE):
ordering = models.int_safe(ordering)
team = get_object_or_404(models.Klb_team, pk=team_id)
context = user_edit_vars(request.user, club=team.club)
participants = team.klb_participant_set.select_related('klb_person')
context['klb_results'] = []
for participant in participants.order_by('klb_person__lname',
'klb_person__fname'):
person = participant.klb_person
results = person.klb_result_set.filter(
event_raw__start_date__year=team.year).select_related(
'race__event', 'event_raw', 'result')
if show_all_results:
results = results.order_by('-event_raw__start_date')
else:
results = results.order_by('-klb_score', '-event_raw__start_date')
if not show_all_results:
results = results.filter(is_in_best=True)
context['klb_results'] += [{
'participant': participant,
'klb_result': klb_result
} for klb_result in results]
context['page_title'] = u'Команда в КЛБМатче: {}, {} год'.format(
team.name, team.year)
context['show_all_results'] = show_all_results
if context['is_admin']:
context['n_seniors'] = participants.filter(is_senior=True).count()
first_participant = participants.exclude(
date_registered=None).order_by('date_registered').first()
if first_participant:
context[
'first_participant_date'] = first_participant.date_registered
context = team.update_context_for_team_page(context,
request.user,
ordering=ordering)
if models.is_active_klb_year(
team.year, context['is_admin']) and (context['is_admin']
or context['is_editor']):
context['n_unpaid_participants'] = team.klb_participant_set.filter(
paid_status=models.PAID_STATUS_NO).count()
if context['n_unpaid_participants']:
context['last_day_to_pay'] = get_last_day_to_pay(team.year)
context[
'n_unpaid_from_all_club_teams'] = models.Klb_participant.objects.filter(
team__club=team.club,
match_year=team.year,
paid_status=models.PAID_STATUS_NO).count()
return render(request, 'klb/team_details.html', context)
def club_records(request, club_id, year=None):
if 'year' in request.POST:
year = models.int_safe(request.POST['year'])
if year < models.FIRST_YEAR_FOR_STAT_UPDATE:
return redirect('results:club_records', club_id=club_id)
if year > datetime.date.today().year:
return redirect('results:club_records', club_id=club_id)
return redirect('results:club_records', club_id=club_id, year=year)
club = get_object_or_404(models.Club, pk=club_id)
user = request.user
context = user_edit_vars(user, club=club)
context['club'] = club
year = models.int_safe(year)
context['year'] = year
context.update(get_club_records_context(club=club, year=year))
context['page_title'] = u'Лучшие результаты клуба «{}» за {}'.format(
club.name, u'{} год'.format(year) if year else u'все годы')
context['template_name'] = 'club/club_records.html'
return render(request, 'results/base_template.html', context)
def event_details(request, event_id=None, event=None, frmDocuments=None, frmNews=None, cloned_event=None, frmEvent=None,
frmForEvent=forms.ForEventForm(auto_id='frmForEvent_%s'), frmForSeries=None, frmRaces=None, news_id=None,
make_news_from_event=False):
if not event: # False if we are creating new event
event = get_object_or_404(models.Event, pk=event_id)
context, has_rights, target = check_rights(request, event=event)
if not has_rights:
return target
if not frmEvent:
initial = {}
if event.city:
initial['city'] = event.city
initial['region'] = event.city.region.id
frmEvent = forms.EventForm(instance=event, initial=initial, user=request.user)
context['event'] = event
context['frmEvent'] = frmEvent
context['frmForEvent'] = frmForEvent
context['cloned_event'] = cloned_event
if cloned_event:
context['page_title'] = u'Клонирование забега'
elif event.id is None:
context['page_title'] = u'Создание нового забега'
else:
context['page_title'] = u'{}, {}'.format(event, event.dateFull())
context['n_documents'] = event.document_set.count()
context['n_news'] = event.news_set.count()
context['n_races'] = event.race_set.count()
if frmRaces is None:
frmRaces = getRaceFormSet(request.user, event)
context['frmRaces'] = frmRaces
if frmDocuments is None:
frmDocuments = getDocumentFormSet(request.user, event)
context['frmDocuments'] = frmDocuments
if frmNews is None:
frmNews = getNewsFormSet(request.user, event, make_news_from_event=make_news_from_event)
if make_news_from_event:
context['races'] = [{'distance': unicode(race.distance), 'race': race}
for race in models.Race.objects.filter(event__series=event.series, event__start_date__lte=datetime.date.today()).order_by(
'distance__distance_type', '-distance__length', '-event__start_date').select_related('distance', 'distance_real', 'event')
]
context['frmNews'] = frmNews
if frmForSeries is None:
frmForSeries = forms.ForSeriesForm(auto_id='frmForSeries_%s')
context['frmForSeries'] = frmForSeries
context['news_id'] = models.int_safe(news_id)
return render(request, "editor/event_details.html", context)
def series_list(request, organizer_id=None):
results = []
query = request.GET.get('query', '').strip()
if len(query) >= MIN_QUERY_LENGTH:
all_good_series = models.Series.objects.all()
if organizer_id:
all_good_series = all_good_series.exclude(organizer_id=organizer_id)
series_id = models.int_safe(query)
if series_id > 0:
series = all_good_series.filter(pk=series_id).first()
if series:
results.append(get_series_dict_for_select(series))
for series in all_good_series.filter(name__icontains=query).order_by('name')[:MAX_ENTRIES]:
results.append(get_series_dict_for_select(series))
return HttpResponse(json.dumps(results), content_type='application/json')
def runner_delete(request, runner_id):
runner = get_object_or_404(models.Runner, pk=runner_id)
has_dependent_objects = runner.has_dependent_objects()
ok_to_delete = False
form = None
new_runner = None
if 'frmForRunner_submit' in request.POST:
if has_dependent_objects:
new_runner_id = models.int_safe(request.POST.get('select_runner'))
if new_runner_id:
if new_runner_id != runner.id:
new_runner = models.Runner.objects.filter(
pk=new_runner_id).first()
if new_runner:
is_merged, msgError = new_runner.merge(
runner, request.user)
if is_merged:
ok_to_delete = True
else:
messages.warning(
request,
u'Не удалось объединить бегунов. Ошибка: {}'.
format(msgError))
else:
messages.warning(
request,
u'Бегун, на которого нужно заменить текущего, не найден.'
)
else:
messages.warning(request,
u'Нельзя заменить бегуна на него же.')
else:
messages.warning(
request,
u'Бегун, на которого нужно заменить текущего, не указан.')
else: # There are no results for runner, so we just delete him
ok_to_delete = True
else:
messages.warning(request, u"Вы не указали бегуна для удаления.")
if ok_to_delete:
delete_runner_for_another(request, request.user, runner,
has_dependent_objects, new_runner)
return redirect(
new_runner if has_dependent_objects else 'results:runners')
return runner_details(request, runner_id=runner_id, runner=runner)
def klb_team_delete_participants(request, team_id):
team = get_object_or_404(models.Klb_team, pk=team_id)
club = team.club
context, has_rights, target = check_rights(request, club=club)
if not has_rights:
return target
if not models.is_active_klb_year(team.year, context['is_admin']):
messages.warning(
request,
u'Вы уже не можете добавлять людей в команду за {} год. Тот матч давно в прошлом.'
.format(team.year))
return redirect(team)
if 'delete_submit' in request.POST:
participants_deleted = 0
for key, val in request.POST.items():
if key.startswith("to_delete_"):
person_id = models.int_safe(key[len("to_delete_"):])
person = models.Klb_person.objects.filter(pk=person_id).first()
if person is None:
messages.warning(
request,
u'Участник КЛБМатчей с id {} не найден. Пропускаем'.
format(person_id))
continue
participant = person.klb_participant_set.filter(
match_year=team.year).first()
if participant is None:
messages.warning(
request,
u'Участник КЛБМатчей {} (id {}) и так не числится в команде. Пропускаем'
.format(person, person.id))
continue
if person.klb_result_set.filter(
race__event__start_date__year=team.year).exists():
messages.warning(
request,
u'Участник КЛБМатчей {} (id {}) уже имеет результаты в зачёт КЛБМатча. Пропускаем'
.format(person, person.id))
continue
models.log_klb_participant_delete(request.user, participant)
participant.delete()
participants_deleted += 1
messages.success(
request,
u'Удалено участников из команды: {}'.format(participants_deleted))
update_team_score(team, to_clean=False, to_calc_sum=True)
return redirect(team)
def klb_team_contact_info(request, team_id, ordering=models.ORDERING_NAME):
ordering = models.int_safe(ordering)
team = get_object_or_404(models.Klb_team, pk=team_id)
context, has_rights, target = check_rights(request, club=team.club)
if not has_rights:
return target
context[
'page_title'] = u'КЛБМатч–{}, команда {}: контактные данные участников'.format(
team.year, team.name)
context = team.update_context_for_team_page(context,
request.user,
ordering=ordering)
context['all_emails'] = u', '.join(
participant.email for participant in context['participants']
if participant.email)
context['is_active_klb_year'] = models.is_active_klb_year(team.year)
return render(request, 'klb/team_contact_info.html', context)
def application_payment(request, year=models.CUR_KLB_YEAR):
context = user_edit_vars(request.user)
year = models.int_safe(year)
if not models.is_active_klb_year(year, context['is_admin']):
year = models.CUR_KLB_YEAR
context['year'] = year
context['price'] = models_klb.get_participation_price(year)
participant = models.Klb_participant.objects.filter(
klb_person__runner__user_id=request.user.id, match_year=year).first()
if not participant:
messages.warning(request,
u'Вы ещё не заявлены в КЛБМатч–{}'.format(year))
return redirect(
reverse('results:klb_application', kwargs={'year': year}))
person = participant.klb_person
if participant.paid_status != models.PAID_STATUS_NO:
messages.warning(
request,
u'Ваше участие в КЛБМатче–{} уже оплачено. Отлично!'.format(year))
return redirect(person)
if participant.team:
club = participant.team.club
if not club.members_can_pay_themselves:
messages.warning(
request,
u'Ваше участие в КЛБМатче может оплатить только капитан команды; Вам достаточно передать деньги ему.'
)
return redirect(person)
context['club'] = club
if participant.is_senior:
context['can_pay_zero'] = True
age = year - person.birthday.year
context['reason'] = u'на конец {} года Вам будет {} {}'.format(
year, age, plural_ending_11(age))
elif person.disability_group != 0:
context['can_pay_zero'] = True
context['reason'] = u'у Вас {} группа инвалидности'.format(
person.disability_group)
else:
context['can_pay_zero'] = False
return render(request, 'klb/application_payment.html', context)
def make_report(request, year, role):
year = models.int_safe(year)
if not models.is_active_klb_year(year):
messages.warning(
request,
u'Сейчас нельзя создавать слепки КЛБМатча за {} год'.format(year))
return redirect('results:reports')
if role != 'client':
role = 'editor'
result, error = mk_table_set_wrapper(role, year, request.user)
if result:
messages.success(
request, u'Слепок КЛБМатча за {} год успешно создан'.format(year))
else:
messages.warning(request,
u'Слепок не создан. Причина: {}'.format(error))
return redirect('results:klb_reports', year=year)
def clubs(request, view=0):
context = user_edit_vars(request.user)
view = models.int_safe(view)
context['page_title'] = u'Клубы любителей бега'
clubs = models.Club.objects.exclude(
pk=models.INDIVIDUAL_RUNNERS_CLUB_NUMBER).select_related(
'city__region__country').prefetch_related(
Prefetch('klb_team_set',
queryset=models.Klb_team.objects.filter(
year=models.CUR_KLB_YEAR).order_by('name')),
'editors').order_by('name')
if not context['is_admin']:
clubs = clubs.filter(is_active=True)
if view == 1:
clubs = clubs.filter(email='')
context['clubs'] = clubs
context['user_is_authenticated'] = request.user.is_authenticated
context['CUR_KLB_YEAR'] = models.CUR_KLB_YEAR
return render(request, 'club/clubs.html', context)
def individual_pay_nothing(request, year=models.CUR_KLB_YEAR):
context = user_edit_vars(request.user)
year = models.int_safe(year)
if not models.is_active_klb_year(year, context['is_admin']):
year = models.CUR_KLB_YEAR
context['year'] = year
participant = models.Klb_participant.objects.filter(
klb_person__runner__user_id=request.user.id, match_year=year).first()
if not participant:
messages.warning(request,
u'Вы ещё не заявлены в КЛБМатч–{}'.format(year))
return redirect(
reverse('results:klb_application', kwargs={'year': year}))
if participant.paid_status != models.PAID_STATUS_NO:
messages.warning(request,
u'Вы уже оплатили участие в КЛБМатче–{}'.format(year))
return redirect(participant.klb_person)
if 'btnJoinForFree' not in request.POST:
return redirect(participant.klb_person)
payment = models.Payment_moneta.objects.create(
amount=0,
is_dummy=True,
is_paid=True,
user=request.user,
)
payment.transaction_id = models.PAYMENT_DUMMY_PREFIX + unicode(payment.id)
payment.save()
participant.payment = payment
participant.paid_status = models.PAID_STATUS_FREE
participant.save()
models.log_obj_create(request.user,
participant.klb_person,
models.ACTION_KLB_PARTICIPANT_UPDATE,
child_object=participant,
field_list=['payment', 'paid_status'],
comment=u'Индивидуальная оплата')
messages.success(request,
u'Отлично, с оплатой разобрались. Пора стартовать!')
return redirect(participant.klb_person)
def remove_from_match(request, year):
year = models.int_safe(year)
target = redirect(
reverse('results:klb_match_summary', kwargs={'year': year}))
if not models.is_active_klb_year(year, models.is_admin(request.user)):
messages.warning(
request,
u'Участников КЛБМатча–{} сейчас нельзя редактировать'.format(year))
return target
participant = None
user = request.user
if hasattr(user, 'runner'):
person = user.runner.klb_person
if person:
participant = person.klb_participant_set.filter(
match_year=year).first()
if participant is None:
messages.warning(request,
u'Вы и не были заявлены в КЛБМатч–{}'.format(year))
return target
if person.klb_result_set.filter(
race__event__start_date__year=year).exists():
messages.warning(request, (
u'У Вас уже есть результаты в зачёт КЛБМатча–{}. Если Вы всё равно хотите отказаться от участия, '
+ u'пожалуйста, напишите нам на {}').format(year, models.KLB_MAIL))
return target
if participant.team:
messages.warning(
request,
(u'Вы заявлены в КЛБМатч–{} за команду «{}». ' +
u'Для отзаявки обратитесь, пожалуйста, к руководителю клуба'
).format(year, participant.team.name))
return target
models.log_klb_participant_delete(user, participant)
participant.delete()
messages.warning(request,
u'Вы успешно отзаявлены из КЛБМатча–{}'.format(year))
return target
def reports(request, year=0):
stat_types = (models.KLB_REPORT_STAT_TEAMS,
models.KLB_REPORT_STAT_PARTICIPANTS,
models.KLB_REPORT_STAT_RESULTS,
models.KLB_REPORT_STAT_GOOD_DISTANCES)
year = models.int_safe(year)
if year < 2018:
year = models.CUR_KLB_YEAR
user = request.user
context = user_edit_vars(user)
context['year'] = year
context['page_title'] = u'КЛБМатч–{}: Слепки'.format(year)
qs = models.Klb_report.objects.all().order_by('-time_created', 'id')
if not context['is_admin']:
qs = qs.filter(is_public=True)
context['reports'] = []
for item in qs:
one_report_info = [
item.year,
os.path.basename(str(item.file)),
'{}/{}'.format(models.SITE_URL_OLD, str(item.file)),
u'Да' if item.is_public else u'Нет',
item.created_by,
item.time_created,
item.id,
]
try:
stat_qs = item.klb_report_stat_set.all()
for stat_type, _ in models.KLB_REPORT_STATS:
one_report_info.append(stat_qs.get(stat_type=stat_type).value)
except models.Klb_report_stat.DoesNotExist:
one_report_info.extend([''] * 4)
context['reports'].append(one_report_info)
return render(request, 'klb/reports.html', context)
def unclaim_results(request):
comment = request.POST.get('comment', "")
results_unclaimed = 0
results_errors = 0
for key, val in request.POST.items():
if key.startswith("unclaim_"):
result_id = models.int_safe(key[8:])
result = request.user.result_set.filter(id=result_id).first()
if result and (result.user == request.user):
result.unclaim_from_user(comment=comment)
results_unclaimed += 1
else:
results_errors += 1
if results_unclaimed > 0:
messages.success(
request, u'Отсоединено результатов: {}.'.format(results_unclaimed))
update_runner_stat(user=request.user)
if results_errors > 0:
messages.warning(
request,
u'Возникли ошибки c {} результатами. Редакторы уже знают о проблеме.'
.format(results_errors))
return redirect('results:home')
