Esempio n. 1
0
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)
Esempio n. 2
0
def klb_team_delete(request, team_id):
    team = get_object_or_404(models.Klb_team, pk=team_id)
    year = team.year
    club = team.club
    context, has_rights, target = check_rights(request, club=club)
    if not has_rights:
        return target
    if year < models.CUR_KLB_YEAR:
        messages.warning(
            request,
            u'Вы уже не можете удалять команды из КЛБМатча-{}. Тот матч давно в прошлом.'
            .format(year))
        return redirect(team)
    if club.klb_team_set.filter(year=year, number__gt=team.number).exists():
        messages.warning(
            request,
            u'Вы можете удалять только команду клуба с максимальным номером. Для более сложных действий,'
            + u' пожалуйста, напишите письмо на {}'.format(models.KLB_MAIL))
        return redirect(team)
    if team.klb_participant_set.exists():
        messages.warning(
            request,
            u'Вы не можете удалить команду, в которой есть хотя бы один участник'
        )
        return redirect(team)
    models.log_obj_delete(request.user, team, action_type=models.ACTION_DELETE)
    messages.success(
        request,
        u'Команда «{}» успешно удалена из КЛБМатча-{}'.format(team.name, year))
    team.delete()
    fill_match_places(year)
    return redirect(club)
Esempio n. 3
0
def runner_name_delete(request, runner_name_id):
	runner_name = get_object_or_404(models.Runner_name, pk=runner_name_id)
	name = runner_name.name
	models.log_obj_delete(request.user, runner_name)
	runner_name.delete()
	messages.success(request, u'Имя «{}» успешно удалено.'.format(name))
	return redirect('editor:runner_names')
Esempio n. 4
0
def city_delete(request, city_id):
    city = get_object_or_404(models.City, pk=city_id)
    has_dependent_objects = city.has_dependent_objects()
    ok_to_delete = False
    if 'frmForCity_submit' in request.POST:
        form = forms.ForCityForm(request.POST, auto_id='frmForCity_%s')
        if form.is_valid():
            if has_dependent_objects:
                city_for = form.cleaned_data['city']
                if city_for != city:
                    ok_to_delete = True
                else:
                    messages.warning(request,
                                     u'Нельзя заменить забег на себя же.')
            else:  # There are no dependent objects of the city, so we just delete it
                ok_to_delete = True
        else:
            messages.warning(
                request,
                u"Город не удалён. Пожалуйста, исправьте ошибки в форме.")
    else:
        form = None
        messages.warning(request, u"Вы не указали город для удаления.")
    if ok_to_delete:
        if has_dependent_objects:
            update_city(request, city, city_for)
        models.log_obj_delete(request.user, city)
        city.delete()
        messages.success(
            request, u'Город «{}» успешно удалён.'.format(city.name_full()))
        if has_dependent_objects:
            return redirect(city_for.get_editor_url())
        else:
            return redirect('editor:city_create')
    return city_details(request, city_id=city_id, city=city, frmForCity=form)
Esempio n. 5
0
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)
Esempio n. 6
0
def news_delete(request, news_id):
    news = get_object_or_404(models.News, pk=news_id)
    ok_to_delete = False

    if (request.method == 'POST') and request.POST.get('frmDeleteNews_submit',
                                                       False):
        models.log_obj_delete(request.user, news)
        news.delete()
        messages.success(request,
                         u'Новость «{}» успешно удалена.'.format(news))
        return redirect('results:all_news')
    return news_details(request, news_id=news_id, news=news)
Esempio n. 7
0
def delete_runner_for_another(request, creator, runner, has_dependent_objects,
                              new_runner):
    if has_dependent_objects:
        update_runner(request, creator, runner, new_runner)
        update_runner_stat(runner=new_runner)
        if new_runner.user:
            update_runner_stat(user=new_runner.user)
    models.log_obj_delete(creator, runner)
    if request:
        messages.success(
            request,
            u'Бегун {} (id {}) успешно удалён.'.format(runner.name(),
                                                       runner.id))
    runner.delete()
Esempio n. 8
0
def delete_member(request, club_id, member_id):
    club = get_object_or_404(models.Club, pk=club_id)
    context, has_rights, target = check_rights(request, club=club)
    if not has_rights:
        return target
    club_member = get_object_or_404(models.Club_member,
                                    club=club,
                                    pk=member_id)
    models.log_obj_delete(request.user,
                          club,
                          child_object=club_member,
                          action_type=models.ACTION_CLUB_MEMBER_DELETE,
                          comment=u'Со страницы члена клуба')
    messages.success(
        request,
        u'{} успешно удалён из клуба «{}».'.format(club_member.runner.name(),
                                                   club.name))
    club_member.delete()
    return redirect(club.get_members_list_url())
Esempio n. 9
0
def event_update(request, event_id):
	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 'frmEvent_submit' in request.POST:
		form = forms.EventForm(request.POST, instance=event, user=request.user)
		if form.is_valid():
			event = form.save()
			log_form_change(request.user, form, action=models.ACTION_UPDATE, exclude=['country', 'region'])
			messages.success(request, u'Пробег «{}» успешно обновлён. Проверьте, всё ли правильно.'.format(event))
			if ('cancelled' in form.changed_data) and event.cancelled:
				n_deleted_races = 0
				for race in list(event.race_set.all()):
					if race.result_set.exists():
						messages.warning(request, u'Дистанция {} не удалена: на ней уже есть результаты. Сначала удалите их'.format(race.distance))
					elif race.klb_result_set.exists():
						messages.warning(request, u'Дистанция {} не удалена: на ней есть результаты в зачёт КЛБМатча. Сначала удалите их'.format(race.distance))
					else:
						models.log_obj_delete(request.user, event, race, models.ACTION_RACE_DELETE, comment=u'При отмене забега')
						race.delete()
						n_deleted_races += 1
				if n_deleted_races:
					messages.success(request, u'Удалено дистанций забега:  {}'.format(n_deleted_races))
			if ('not_in_klb' in form.changed_data) and event.not_in_klb:
				klb_result_actions = models.Table_update.objects.filter(
					model_name=event.__class__.__name__,
					row_id=event.id,
					action_type__in=models.RESULT_ACTIONS,
					is_verified=False,
					is_for_klb=True
				)
				if klb_result_actions.exists():
					n_klb_result_actions = klb_result_actions.count()
					klb_result_actions.update(is_for_klb=False)
					messages.success(request, u'Запросов на модерацию в КЛБМатч отменено, поскольку забег помечен как негодный: {}'.format(n_klb_result_actions))
			return redirect(event.get_editor_url())
		else:
			messages.warning(request, u'Пробег не обновлён. Пожалуйста, исправьте ошибки в форме.')
	else:
		form = forms.EventForm(instance=event, user=request.user)
	return event_details(request, event_id=event_id, event=event, frmEvent=form)
Esempio n. 10
0
def club_delete(request, club_id):
    club = get_object_or_404(models.Club, pk=club_id)
    context, has_rights, target = check_rights(request, club=club)
    if not has_rights:
        return target
    has_dependent_objects = club.has_dependent_objects()
    ok_to_delete = False
    form = None
    if 'frmForClub_submit' in request.POST:
        if has_dependent_objects:
            messages.warning(request, u"Нельзя удалять клуб с командами.")
            # new_club_id = models.int_safe(request.POST.get('select_club'))
            # if new_club_id:
            # 	if new_club_id != club.id:
            # 		new_club = models.Club.objects.filter(pk=new_club_id).first()
            # 		if new_club:
            # 			is_merged, msgError = new_club.merge(club, 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 club, so we just delete him
            ok_to_delete = True
    else:
        messages.warning(request, u"Вы не указали клуб для удаления.")

    if ok_to_delete:
        models.log_obj_delete(request.user, club)
        messages.success(request, u'Клуб «{}» успешно удалён.'.format(club))
        club.delete()
        if has_dependent_objects:
            pass
            # return redirect(new_club)
        else:
            return redirect('results:clubs')
    return club_details(request, club_id=club_id, club=club)
Esempio n. 11
0
def distance_delete(request, distance_id):
    distance = get_object_or_404(models.Distance, pk=distance_id)
    has_dependent_objects = distance.has_dependent_objects()
    ok_to_delete = False
    if (request.method == 'POST') and request.POST.get('frmForDistance_submit',
                                                       False):
        form = forms.ForDistanceForm(request.POST, auto_id='frmForDistance_%s')
        if form.is_valid():
            if has_dependent_objects:
                new_distance = form.cleaned_data['new_distance']
                if new_distance != distance:
                    ok_to_delete = True
                else:
                    messages.warning(request,
                                     u'Нельзя заменить дистанцию на неё же.')
            else:  # There are no dependent races or splits, so we can delete it
                ok_to_delete = True
        else:
            messages.warning(
                request,
                u"Дистанция не создана. Пожалуйста, исправьте ошибки в форме.")
    else:
        form = forms.ForDistanceForm(auto_id='frmForDistance_%s')
        messages.warning(request, u"Вы не указали город для удаления.")

    if ok_to_delete:
        if has_dependent_objects:
            update_distance(request, distance, new_distance)
        models.log_obj_delete(request.user, distance)
        distance.delete()
        messages.success(request,
                         u'Дистанция «{}» успешно удалена.'.format(distance))
        if has_dependent_objects:
            return redirect(new_distance.get_editor_url())
        else:
            return redirect('editor:distances')

    return distance_details(request,
                            distance_id=distance_id,
                            distance=distance,
                            frmForDistance=form)
Esempio n. 12
0
def try_merge_klb_persons_and_runners(user, person1, person2):
    success, msg = try_only_merge_klb_persons(user, person1, person2)
    if not success:
        return False, msg
    if person1.klb_participant_set.exists():
        return False, u'Возникла ошибка: у участника КЛБМатчей с id {} остались записи в Klb_participant! Ничего не делаем'.format(
            person1.id)
    if person1.klb_result_set.exists():
        return False, u'Возникла ошибка: у участника КЛБМатчей с id {} остались записи в Klb_result! Ничего не делаем'.format(
            person1.id)
    models.log_obj_delete(user, person1)
    runner1 = person1.runner
    runner2 = person2.runner
    person1_id = person1.id
    person1.delete()
    runner1.refresh_from_db()
    success, msg = runner2.merge(runner1, user)
    if not success:
        return False, u'Мы удалили участника КЛБМатчей с id {}, но не смогли заменить бегуна с id {} на бегуна {}: {}. Сделайте это!'.format(
            person1_id, runner1.id, runner2.id, msg)
    return True, ''
Esempio n. 13
0
def remove_races_with_no_results(request, event_id):
	event = get_object_or_404(models.Event, pk=event_id)

	if not event.is_in_past():
		messages.warning(request, u'Этот забег ещё не прошёл. Ничего не удаляем')
		return redirect(event)

	if not models.Result.objects.filter(race__event=event).exists():
		messages.warning(request, u'У этого забега вообще нет ни одного результат. Возможно, протокол ещё не загружен? Ничего не удаляем')
		return redirect(event)

	n_deleted = 0
	for race in list(event.race_set.all()):
		if (not race.result_set.exists()) and (not race.klb_result_set.exists()):
			models.log_obj_delete(request.user, event, race, models.ACTION_RACE_DELETE, comment=u'При удалении дистанций без единого результата')
			race.delete()
			n_deleted += 1

	if n_deleted:
		messages.success(request, u'Удалено дистанций без результатов у забега: {}'.format(n_deleted))
	else:
		messages.warning(request, u'Дистанций без результатов не найдено. Ничего не удаляем')
	return redirect(event)
Esempio n. 14
0
def result_delete(request, result_id):
	result = get_object_or_404(models.Result, pk=result_id)
	race = result.race
	models.log_obj_delete(request.user, race.event, child_object=result)
	res_str = unicode(result)
	if hasattr(result, 'klb_result'):
		year = race.event.start_date.year
		if models.is_active_klb_year(year):
			person = result.klb_result.klb_person
			team = result.klb_result.klb_participant.team
			result.klb_result.delete()
			update_persons_score(year=year, persons_to_update=[person], update_runners=True)
			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.warning(request, u'Результат из КЛБМатча успешно удалён')
	runner = result.runner
	result.delete()
	if runner:
		update_runner_stat(runner=runner)
		if runner.user:
			update_runner_stat(user=runner.user)
	fill_places(race)
	fill_race_headers(race)
	messages.success(request, u"Результат {} на забеге «{}» успешно удалён. Места проставлены заново, числа участников обновлены".format(
		res_str, race))
	return redirect(race)
Esempio n. 15
0
def klb_race_process(request, race_id=None):
    race = get_object_or_404(models.Race, pk=race_id)
    event = race.event
    year = event.start_date.year
    user = request.user
    distance, was_real_distance_used = race.get_distance_and_flag_for_klb()
    page = None
    if models.Klb_result.objects.filter(race=race, result=None).exists():
        messages.warning(
            request,
            u'На этой дистанции есть результаты, проведённые в КЛБМатч, но не привязанные к загруженным результатам.'
        )
    elif request.method == 'POST':
        results_added = 0
        results_deleted = 0
        results_errors = 0
        touched_persons = set()
        touched_teams = Counter()
        page = models.int_safe(request.POST.get('page', 0))
        pages_number = get_pages_number(
            race.result_set.filter(source=models.RESULT_SOURCE_DEFAULT,
                                   status=models.STATUS_FINISHED).count())
        only_bonus_score = 'only_bonus_score' in request.POST
        for key, val in request.POST.items():
            if key.startswith("person_for_"):
                person_id = models.int_safe(val)
                if person_id == 0:
                    continue
                result_id = models.int_safe(key[len("person_for_"):])
                result = models.Result.objects.filter(race=race,
                                                      id=result_id,
                                                      klb_result=None).first()
                if result is None:
                    messages.warning(
                        request,
                        u'Результат с id {} не найден. Пропускаем'.format(
                            result_id))
                    continue
                if hasattr(result, 'klb_result'):
                    messages.warning(
                        request,
                        u'Результат с id {} уже учтён в КЛБМатче. Пропускаем'.
                        format(result_id))
                    continue
                person = models.Klb_person.objects.filter(pk=person_id).first()
                if not person:
                    messages.warning(
                        request,
                        u'{} {}: участник КЛБМатчей с id {} не найден. Пропускаем'
                        .format(result.fname, result.lname, person_id))
                    continue
                if not check_results_with_same_time(request, race, event,
                                                    person, result):
                    continue
                # We can have two runners: from result and from person
                if result.runner:
                    runner = result.runner
                    if hasattr(person, 'runner'):
                        if runner != person.runner:
                            messages.warning(request, (
                                u'{} {}: у результата и участника Матча два разных бегуна, {} и {}. '
                                + u'Сначала объедините их').format(
                                    result.fname, result.lname, result.runner,
                                    person.runner))
                            continue
                        # If runner == person.runner, we just do nothing
                    elif runner.klb_person_id and (runner.klb_person_id !=
                                                   person.id):
                        messages.warning(request, (
                            u'{} {}: В БД результатов указан другой бегун – с id {}. Пропускаем'
                        ).format(result.fname, result.lname,
                                 runner.klb_person_id))
                        continue
                    # So result has its runner, person doesn't have, and either runner.klb_person_id = person.id or runner.klb_person_id=None
                    if runner.klb_person_id is None:
                        runner.klb_person = person
                        runner.save()
                        person.refresh_from_db()
                # Great! That's time to create KLBResult
                create_klb_result(
                    result,
                    person,
                    user,
                    distance,
                    was_real_distance_used,
                    only_bonus_score=only_bonus_score,
                    comment=u'Со страницы обработки официальных результатов')
                table_update = models.Table_update.objects.filter(
                    model_name=event.__class__.__name__,
                    row_id=event.id,
                    child_id=result.id,
                    action_type=models.ACTION_RESULT_UPDATE,
                    is_verified=False,
                ).first()
                if table_update:
                    table_update.verify(
                        request.user,
                        comment=u'одобрено при обработке старта целиком')
                touched_persons.add(person)
                # update_participant_score(person)
                team = person.get_team(year)
                if team:
                    touched_teams[team] += 1
                results_added += 1
            elif key.startswith("to_delete_"):
                result_id = models.int_safe(key[len("to_delete_"):])
                result = models.Result.objects.filter(
                    race=race, id=result_id, klb_result__isnull=False).first()
                if not result:
                    messages.warning(
                        request,
                        u'Результат с id {} не найден. Пропускаем'.format(
                            result_id))
                    continue
                klb_result = result.klb_result
                touched_persons.add(klb_result.klb_person)
                team = klb_result.get_team()
                if team:
                    touched_teams[team] += 1
                models.log_obj_delete(
                    user,
                    event,
                    child_object=klb_result,
                    action_type=models.ACTION_KLB_RESULT_DELETE)
                klb_result.delete()
                if 'to_unclaim_{}'.format(result_id) in request.POST:
                    result.unclaim_from_runner(user)
                results_deleted += 1
        if results_added:
            messages.success(
                request,
                u'В КЛБМатч добавлено результатов: {}'.format(results_added))
            race.fill_winners_info()
        if results_deleted:
            messages.success(
                request,
                u'Из КЛБМатча удалено результатов: {}'.format(results_deleted))
        if touched_persons:
            update_persons_score(year=year,
                                 persons_to_update=touched_persons,
                                 update_runners=True)
            messages.success(
                request,
                u'Затронуто участников Матча: {}. Их результаты пересчитаны.'.
                format(len(touched_persons)))
        if touched_teams:
            messages.success(
                request, u'Затронуты команды: {}'.format(', '.join(
                    team.name for team in touched_teams)))
            for team in touched_teams:
                prev_score = team.score
                team.refresh_from_db()
                models.Klb_team_score_change.objects.create(
                    team=team,
                    race=race,
                    clean_sum=team.score - team.bonus_score,
                    bonus_sum=team.bonus_score,
                    delta=team.score - prev_score,
                    n_persons_touched=touched_teams[team],
                    comment=u'Обработка всей дистанции в КЛБМатч',
                    added_by=user,
                )
        if (not race.was_checked_for_klb) and (page == pages_number - 1):
            race.was_checked_for_klb = True
            race.save()
            models.log_obj_create(user,
                                  event,
                                  models.ACTION_RACE_UPDATE,
                                  field_list=['was_checked_for_klb'],
                                  child_object=race)
    return redirect(race.get_klb_editor_url(page=page))
Esempio n. 16
0
def series_delete(request, series_id):
    series = get_object_or_404(models.Series, pk=series_id)
    context, has_rights, target = check_rights(request, series=series)
    if not has_rights:
        return target
    has_dependent_objects = series.has_dependent_objects()
    ok_to_delete = False

    if (request.method == 'POST') and request.POST.get('frmForSeries_submit',
                                                       False):
        form = forms.ForSeriesForm(request.POST, auto_id='frmForSeries_%s')
        if form.is_valid():
            if has_dependent_objects:
                new_series_id = models.int_safe(
                    request.POST.get('new_series_id', 0))
                if new_series_id:
                    if new_series_id != series.id:
                        new_series = models.Series.objects.filter(
                            pk=new_series_id).first()
                        if new_series:
                            ok_to_delete = True
                        else:
                            messages.warning(
                                request,
                                u'Серия, на которую нужно заменить текущую, не найдена.'
                            )
                    else:
                        messages.warning(request,
                                         u'Нельзя заменить серию на неё же.')
                else:
                    messages.warning(
                        request,
                        u'Серия, на которую нужно заменить текущую, не указана.'
                    )
            else:  # There are no events in the series, so we just delete it
                ok_to_delete = True
        else:
            messages.warning(
                request,
                u"Серия не удалена. Пожалуйста, исправьте ошибки: {}".format(
                    form.errors))
    else:
        form = forms.ForSeriesForm(auto_id='frmForSeries_%s')
        messages.warning(request, u"Вы не указали серию для удаления.")

    if ok_to_delete:
        if not has_dependent_objects:
            new_series_id = 0
            new_series = None
        log = logging.getLogger('structure_modification')
        log_prefix = 'series_delete: series {}->{}, by user {}.'.format(
            series_id, new_series_id, request.user.id)
        log_exc_info = False
        log.debug('{} before flock'.format(log_prefix))
        with Flock_mutex(LOCK_FILE_FOR_RATED_TREE_MODIFICATIONS):
            try:
                with transaction.atomic():
                    if has_dependent_objects:
                        update_series(request, series, new_series)
                    transfer_children_before_node_deletion(series, new_series)
                    models.log_obj_delete(request.user, series)
                    series.delete()
                log.debug('{} trnsctn end'.format(log_prefix))
            except (UpdatedRecordExistsError, AssertionError) as e:
                error_msg = repr(e)
                if isinstance(e, AssertionError):
                    log_exc_info = True
            except Exception as e:
                log.error('{} Unexpected error: {}'.format(
                    log_prefix, repr(e)),
                          exc_info=True)
                raise
            else:
                error_msg = None
        if error_msg is None:
            log.info('{} OK'.format(log_prefix))
            messages.success(request,
                             u'Серия «{}» успешно удалена.'.format(series))
        else:
            log.error('{} {}'.format(log_prefix, error_msg),
                      exc_info=log_exc_info)
            messages.warning(
                request, u'Не удалось удалить серию «{}» ({}).'.format(
                    series, error_msg))

        if has_dependent_objects:
            return redirect(new_series)
        else:
            return redirect('results:races')

    return series_details(request,
                          series_id=series_id,
                          series=series,
                          frmForSeries=form)
Esempio n. 17
0
def organizer_delete(request, organizer_id):
	organizer = get_object_or_404(models.Organizer, pk=organizer_id)
	has_dependent_objects = organizer.has_dependent_objects()
	ok_to_delete = False
	if 'frmForOrganizer_submit' in request.POST:
		form = forms.ForOrganizerForm(request.POST, auto_id='frmForOrganizer_%s')
		if form.is_valid():
			if has_dependent_objects:
				organizer_for = form.cleaned_data['organizer']
				if organizer_for != organizer:
					ok_to_delete = True
				else:
					messages.warning(request, u'Нельзя заменить организатора на его самого.')
			else: # There are no dependent objects of the organizer, so we just delete it
				ok_to_delete = True
		else:
			messages.warning(request, u'Организатор не удалён. Пожалуйста, исправьте ошибки в форме.')
	else:
		form = None
		messages.warning(request, u'Вы не указали город для удаления.')
	if ok_to_delete:
		# NOT TESTED !
		if has_dependent_objects:
			organizer_for_id = organizer_for.id
		else:
			organizer_for_id = 0
			organizer_for = None
		log = logging.getLogger('structure_modification')
		log_prefix = 'organizer_delete: organizer {}->{}, by user {}.'.format(
			organizer_id, organizer_for_id, request.user.id
		)
		log_exc_info = False
		oranizer_name_full = organizer.name_full()
		log.debug('{} before flock'.format(log_prefix))
		with Flock_mutex(LOCK_FILE_FOR_RATED_TREE_MODIFICATIONS):
			try:
				with transaction.atomic():
					if has_dependent_objects:
						update_organizer(request, organizer, organizer_for)
					models.log_obj_delete(request.user, organizer)
					organizer.delete()
				log.debug('{} trnsctn end'.format(log_prefix))
			except (UpdatedRecordExistsError, AssertionError) as e:
				error_msg = repr(e)
				if isinstance(e, AssertionError):
					log_exc_info = True
			except Exception as e:
				log.error('{} Unexpected error: {}'.format(log_prefix, repr(e)), exc_info=True)
				raise
			else:
				error_msg = None
		if error_msg is None:
			log.info('{} OK'.format(log_prefix))
			messages.success(request, u'Организатор «{}» успешно удалён.'.format(organizer_name_full))
		else:
			log.error('{} {}'.format(log_prefix, error_msg), exc_info=log_exc_info)
			messages.warning(
				request, u'Не удалось удалить организатора «{}» ({}).'.format(
					organizer_name_full, error_msg
				)
			)
		if has_dependent_objects:
			return redirect(organizer_for.get_editor_url())
		else:
			return redirect('editor:organizer_create')
	return organizer_details(request, organizer_id=organizer_id)
Esempio n. 18
0
def registration_details(request, event_id=None):
	registration = get_object_or_404(models.Registration, event_id=event_id)
	event = registration.event
	context, has_rights, target = check_rights(request, event=event)
	if not has_rights:
		return target

	user = request.user
	frmRegistration = None
	frmQuestions = None
	frmNewRace = None
	frmRaces = None

	if 'frmRegistration_submit' in request.POST:
		frmRegistration = forms.RegistrationForm(request.POST, instance=registration)
		if frmRegistration.is_valid():
			if ('is_open' in frmRegistration.changed_data) and frmRegistration.instance.is_open:
				if not models.Reg_race_details.objects.filter(race__event=event, is_open=True).exists():
					frmRegistration.instance.is_open = False
					messages.warning(request, u'Регистрация оставлена закрытой, поскольку закрыты регистрации на все дистанции. Сначала откройте хотя бы одну ниже')
			registration = frmRegistration.save()
			log_form_change(user, frmRegistration, action=models.ACTION_UPDATE)
			messages.success(request, u'Регистрация на забег «{}» успешно обновлена. Проверьте, всё ли правильно.'.format(event))
			return redirect(registration.get_editor_url())
		else:
			messages.warning(request, u"Регистрация не обновлена. Пожалуйста, исправьте ошибки в форме.")
	elif 'frmQuestions_submit' in request.POST:
		frmQuestions = getRegQuestionFormSet(event, user, data=request.POST, files=request.FILES)
		if frmQuestions.is_valid():
			instances = frmQuestions.save()
			log_document_formset(user, registration, frmQuestions)

			if len(frmQuestions.deleted_objects):
				refresh_numbers(event.reg_question_set)

			for question in frmQuestions.new_objects:
				for race in event.get_reg_race_set():
					models.Reg_question_race.objects.create(
						reg_question=question,
						race=race,
						added_by=user,
					)

			messages.success(request, (u'Вопросы регистрации на забег«{}» успешно обновлены: {} вопросов добавлено, {} обновлено, '
				+ u'{} удалено. Проверьте, всё ли правильно.').format(
				event, len(frmQuestions.new_objects), len(frmQuestions.changed_objects), len(frmQuestions.deleted_objects)))
			return redirect(registration.get_editor_url())
		else:
			messages.warning(request, u"Вопросы регистрации не обновлены. Пожалуйста, исправьте ошибки в форме.")
	elif 'frmRaces_submit' in request.POST:
		frmRaces = getRegRaceFormSet(event, data=request.POST)
		if frmRaces.is_valid():
			instances = frmRaces.save()
			log_document_formset(user, registration, frmRaces)
			messages.success(request, (u'Дистанции регистрации на забег«{}» успешно обновлены: {} вопросов добавлено, {} обновлено, '
				+ u'{} удалено. Проверьте, всё ли правильно.').format(
				event, len(frmRaces.new_objects), len(frmRaces.changed_objects), len(frmRaces.deleted_objects)))
			return redirect(registration.get_editor_url())
		else:
			messages.warning(request, u"Дистанции не обновлены. Пожалуйста, исправьте ошибки в форме.")
	elif 'frmNewRace_submit' in request.POST:
		frmNewRace = forms.RegNewRaceForm(event=event, data=request.POST)
		if frmNewRace.is_valid():
			race_new = frmNewRace.cleaned_data['race_new']
			race_template = frmNewRace.cleaned_data.get('race_template')
			if race_template:
				reg_race_details = race_template.reg_race_details
				reg_race_details.id = None
			else:
				reg_race_details = models.Reg_race_details()
			reg_race_details.race = race_new
			reg_race_details.created_by = user
			reg_race_details.save()
			models.log_obj_create(user, registration, models.ACTION_REG_RACE_CREATE, child_object=reg_race_details, comment=u'При добавлении регистрации на дистанцию')
			if race_template:
				for question in race_template.reg_question_set.all():
					models.Reg_question_race.objects.create(
						reg_question=question,
						race=race_new,
						added_by=user,
					)
				for race_cost in list(race_template.race_cost_set.all()):
					race_cost_new = race_cost
					race_cost_new.id = None
					race_cost_new.race = race_new
					race_cost_new.created_by = user
					race_cost_new.save()
					models.log_obj_create(user, registration, models.ACTION_RACE_COST_CREATE, child_object=race_cost_new, comment=u'При добавлении регистрации на дистанцию')
				messages.success(request, u'Регистрация на дистанцию {} по образцу дистанции {} открыта. Проверьте, всё ли правильно'.format(
					race_new, race_template))
			else:
				race_cost_new = models.Race_cost.objects.filter(race__event=event, finish_date=None).first()
				if race_cost_new:
					race_cost_new.id = None
				else:
					race_cost_new = models.Race_cost(cost=models.Race_cost.get_default_cost())
				race_cost_new.race = race_new
				race_cost_new.created_by = user
				race_cost_new.save()
				models.log_obj_create(user, registration, models.ACTION_RACE_COST_CREATE, child_object=race_cost_new, comment=u'При добавлении регистрации на дистанцию')
				messages.success(request, u'Регистрация на дистанцию {} открыта. Проверьте, всё ли правильно, и добавьте нужные цены регистрации и вопросы'.format(
					race_new))
			return redirect(registration.get_editor_url())
		else:
			messages.warning(request, u"Новая регистрация не создана. Пожалуйста, исправьте ошибки в форме.")
	elif 'frmDeleteRegistration_submit' in request.POST:
		if not registration.has_dependent_objects():
			models.log_obj_delete(user, registration)
			registration.delete()
			messages.success(request, u'Регистрация успешно удалена.')
			return redirect(event)
		else:
			messages.warning(request, u'Для удаления регистрации не должно быть ни вопросов в ней, ни уже зарегистрированных людей')
	else:
		for question in event.reg_question_set.all():
			if 'move_question_{}_submit'.format(question.id) in request.POST:
				if try_move_choice(event.reg_question_set, question, models.int_safe(request.POST.get('move_question_{}'.format(question.id)))):
					messages.success(request, u'Вопрос «{}» успешно перемещён'.format(question.title))
				else:
					messages.success(request, u'Вопрос «{}» оставлен на месте'.format(question.title))
				return redirect(registration.get_editor_url())

	context['event'] = event
	context['registration'] = registration
	context['n_questions'] = event.reg_question_set.count()
	context['move_choices'] = forms.QUESTION_MOVE_CHOICES
	context['races_with_registration'] = event.get_reg_race_set()
	context['page_title'] = u'Регистрация на забег «{}»'.format(event)

	context['frmRegistration'] = frmRegistration if frmRegistration else forms.RegistrationForm(instance=registration)
	context['frmQuestions'] = frmQuestions if frmQuestions else getRegQuestionFormSet(event, user)
	context['frmRaces'] = frmRaces if frmRaces else getRegRaceFormSet(event)
	if context['races_with_registration'].count() < event.race_set.count():
		context['frmNewRace'] = frmNewRace if frmNewRace else forms.RegNewRaceForm(event=event)

	return render(request, "editor/registration/reg_details.html", context)
Esempio n. 19
0
def event_delete(request, event_id):
	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
	has_dependent_objects = event.has_dependent_objects()
	ok_to_delete = False
	if 'frmForEvent_submit' in request.POST:
		form = forms.ForEventForm(request.POST, auto_id='frmForEvent_%s')
		if form.is_valid():
			if has_dependent_objects:
				new_event_id = models.int_safe(request.POST.get('new_event_id', 0))
				if new_event_id:
					if new_event_id != event.id:
						new_event = models.Event.objects.filter(pk=new_event_id).first()
						if new_event:
							ok_to_delete = True
						else:
							messages.warning(request, u'Забег, на который нужно заменить текущий, не найден.')
					else:
						messages.warning(request, u'Нельзя заменить забег на себя же.')
				else:
					messages.warning(request, u'Забег, на который нужно заменить текущий, не указан.')
			else: # There are no races in the event, so we just delete it
				ok_to_delete = True
		else:
			messages.warning(request, u"Забег не удалён. Пожалуйста, исправьте ошибки в форме.")
	else:
		form = None
		messages.warning(request, u"Вы не указали забег для удаления.")
	if ok_to_delete:
		if not has_dependent_objects:
			new_event_id = 0
			new_event = None
		log = logging.getLogger('structure_modification')
		log_prefix = 'event_delete: event {}->{}, by user {}.'.format(event_id, new_event_id, request.user.id)
		log.debug('{} before flock'.format(log_prefix))
		log_exc_info = False
		with Flock_mutex(LOCK_FILE_FOR_RATED_TREE_MODIFICATIONS):
			event_name = event.name
			series = event.series
			log.debug('{} trnsctn start'.format(log_prefix))
			try:
				with transaction.atomic():
					if has_dependent_objects:
						update_event(request, event, new_event)
					log.debug('{} 1'.format(log_prefix))
					transfer_children_before_node_deletion(event, new_event)
					log.debug('{} 2'.format(log_prefix))
					models.log_obj_delete(request.user, event)
					log.debug('{} 3'.format(log_prefix))
					start_date = event.start_date
					event.delete()
					log.debug('{} 4'.format(log_prefix))
					update_events_count()
					log.debug('{} 5'.format(log_prefix))
					update_course_records(series)
					if event.series.is_russian_parkrun():
						log.debug('{} 6'.format(log_prefix))
						prev_event = series.event_set.filter(start_date__lt=start_date).order_by('-start_date').first()
						if prev_event:
							_, n_fixed_parkruns = views_parkrun.fix_parkrun_numbers(correct_event=prev_event)
							messages.success(request, u'Исправлена нумерация у {} паркран{} после удалённого'.format(n_fixed_parkruns,
								results_util.plural_ending_new(n_fixed_parkruns, 1)))
				log.debug('{} trnsctn end'.format(log_prefix))
			except (UpdatedRecordExistsError, AssertionError) as e:
				error_msg = repr(e)
				if isinstance(e, AssertionError):
					log_exc_info = True
			except Exception as e:
				log.error('{} Unexpected error: {}'.format(log_prefix, repr(e)), exc_info=True)
				raise
			else:
				error_msg = None
		if error_msg is None:
			log.info('{} OK'.format(log_prefix))
			messages.success(request, u'Забег «{}» из серии «{}» успешно удалён.'.format(event_name, series))
		else:
			log.error('{} {}'.format(log_prefix, error_msg), exc_info=log_exc_info)
			messages.warning(
				request, u'Не удалось удалить забег «{}» из серии «{}»<br />({}).'.format(
					event_name, series, error_msg
				)
			)
		return redirect(event.series)

	return event_details(request, event_id=event_id, event=event, frmForEvent=form)
Esempio n. 20
0
def klb_person_participant_update(request, person_id, year):
    person = get_object_or_404(models.Klb_person, pk=person_id)
    year = models.int_safe(year)
    if not models.is_active_klb_year(year, True):
        messages.warning(
            request, u'Участников КЛБМатча-{} сейчас нельзя редактировать')
        return redirect(person)
    participant = person.klb_participant_set.filter(match_year=year).first()
    if 'frmParticipant_submit' in request.POST:
        if participant:  # We just update participant's fields
            form = forms.KlbParticipantForm(request.POST,
                                            instance=participant,
                                            year=year)
            if form.is_valid():
                participant = form.save()
                team = participant.team
                log_form_change(request.user,
                                form,
                                models.ACTION_KLB_PARTICIPANT_UPDATE,
                                obj=person,
                                child_id=participant.id)
                messages.success(
                    request,
                    u'Данные об участии в КЛБМатче-{} успешно обновлены. Изменены следующие поля: {}'
                    .format(year, ", ".join(form.changed_data)))
                person.update_person_contact_fields_and_prepare_letter(
                    request.user, team, participant.email,
                    participant.phone_number)
                deleted_race_ids = []
                klb_results = person.klb_result_set.filter(
                    race__event__start_date__year=year)
                if ('date_registered'
                        in form.changed_data) and participant.date_registered:
                    for klb_result in klb_results.filter(
                            race__event__start_date__lt=participant.
                            date_registered):
                        models.log_obj_delete(
                            request.user,
                            klb_result.race.event,
                            child_object=klb_result,
                            action_type=models.ACTION_KLB_RESULT_DELETE,
                            comment=u'При изменении дат участия в КЛБМатче')
                        deleted_race_ids.append(klb_result.race.id)
                        if team:
                            prev_score = team.score
                            team.refresh_from_db()
                            models.Klb_team_score_change.objects.create(
                                team=team,
                                race=klb_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,
                                    participant.date_registered.isoformat()),
                                added_by=request.user,
                            )
                        klb_result.delete()
                if ('date_removed'
                        in form.changed_data) and participant.date_removed:
                    for klb_result in klb_results.filter(
                            race__event__start_date__gt=participant.
                            date_removed):
                        models.log_obj_delete(
                            request.user,
                            klb_result.race.event,
                            child_object=klb_result,
                            action_type=models.ACTION_KLB_RESULT_DELETE,
                            comment=u'При изменении дат участия в КЛБМатче')
                        deleted_race_ids.append(klb_result.race.id)
                        if team:
                            prev_score = team.score
                            team.refresh_from_db()
                            models.Klb_team_score_change.objects.create(
                                team=team,
                                race=klb_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,
                                        participant.date_removed.isoformat()),
                                added_by=request.user,
                            )
                        klb_result.delete()
                if deleted_race_ids:
                    messages.warning(
                        request,
                        u'Удалены КЛБ-результаты со стартов со следующими id: {}'
                        .format(', '.join(
                            unicode(x) for x in deleted_race_ids)))
                    update_participant_score(participant, to_update_team=True)
                    if participant.team:
                        fill_match_places(year=year, fill_age_places=False)
                return redirect(person.get_editor_url())
            else:
                messages.warning(
                    request,
                    u"Данные об участии в КЛБМатче-{} не обновлены. Пожалуйста, исправьте ошибки в форме."
                    .format(year))
        else:  # We should create new participant
            participant = models.Klb_participant(added_by=request.user,
                                                 klb_person=person,
                                                 match_year=year)
            form = forms.KlbParticipantForm(request.POST,
                                            instance=participant,
                                            year=year)
            if form.is_valid():
                team = form.instance.team
                team_limit = models_klb.get_team_limit(year)
                if (team is None) or (team.n_members < team_limit):
                    participant = form.save()
                    participant.fill_age_group()
                    log_form_change(request.user,
                                    form,
                                    models.ACTION_KLB_PARTICIPANT_CREATE,
                                    obj=person,
                                    child_id=participant.id)
                    person.update_person_contact_fields_and_prepare_letter(
                        request.user,
                        team,
                        participant.email,
                        participant.phone_number,
                        prepare_letter=True,
                        year=year)

                    if ('and_to_club_members' in request.POST) and team:
                        if participant.date_registered:
                            date_from = max(participant.date_registered,
                                            datetime.date(year, 1, 1))
                        else:
                            date_from = datetime.date(year, 1, 1)
                        if participant.date_removed:
                            date_to = min(participant.date_removed,
                                          datetime.date(year, 12, 31))
                        else:
                            date_to = datetime.date(year, 12, 31)
                        club_member, is_changed = person.runner.add_to_club(
                            request.user, team.club, participant, date_from,
                            date_to)
                        if is_changed:
                            update_runner_stat(club_member=club_member)

                    messages.success(
                        request,
                        u'Участник успешно добавлен в КЛБМатч-{}'.format(year))
                    if participant.team:
                        update_team_score(participant.team, to_calc_sum=True)
                    return redirect(person.get_editor_url())
                else:
                    messages.warning(
                        request,
                        u"В команде «{}» достигнут лимит участников ({} человек)."
                        .format(team.name, team_limit))
            else:
                messages.warning(
                    request,
                    u"Данные об участии в КЛБМатче-{} не обновлены. Пожалуйста, исправьте ошибки в форме."
                    .format(year))
    elif 'frmParticipant_delete' in request.POST:
        if participant:
            deleted_race_ids = []
            team = participant.team
            for klb_result in person.klb_result_set.filter(
                    race__event__start_date__year=year):
                models.log_obj_delete(
                    request.user,
                    klb_result.race.event,
                    child_object=klb_result,
                    action_type=models.ACTION_KLB_RESULT_DELETE,
                    comment=u'При удалении человека из КЛБМатча')
                deleted_race_ids.append(klb_result.race.id)
                klb_result.delete()
            if deleted_race_ids:
                messages.warning(
                    request,
                    u'Удалены КЛБ-результаты со стартов со следующими id: {}'.
                    format(', '.join(unicode(x) for x in deleted_race_ids)))
            models.log_klb_participant_delete(request.user, participant)
            participant.delete()
            messages.success(request, u'Участник удалён из КЛБМатча')
            if team:
                update_team_score(team,
                                  to_calc_sum=(len(deleted_race_ids) > 0))
                fill_match_places(year=year, fill_age_places=False)
            return redirect(person.get_editor_url())
        else:  # We should create new participant
            messages.warning(
                request,
                u"Этот человек и так не участвует в КЛБМатче-{}".format(year))
    else:
        form = None
    return klb_person_details(request,
                              person_id=person_id,
                              person=person,
                              frmParticipant=form)