def standings_list(request, template='standings_list.html', extra_context=None): contests = Contest.objects \ .select_related('timing') \ .annotate(has_statistics=Exists(Statistics.objects.filter(contest=OuterRef('pk')))) \ .annotate(has_module=Exists(Module.objects.filter(resource=OuterRef('resource_id')))) \ .filter(Q(has_statistics=True) | Q(end_time__lte=timezone.now())) \ .order_by('-end_time') all_standings = False if request.user.is_authenticated: all_standings = request.user.coder.settings.get('all_standings') switch = 'switch' in request.GET if bool(all_standings) == bool(switch): contests = contests.filter(has_statistics=True, has_module=True) if request.user.is_authenticated: contests = contests.filter(request.user.coder.get_contest_filter(['list'])) search = request.GET.get('search') if search is not None: contests = contests.filter(get_iregex_filter(search, 'title', 'host', 'resource__host', mapping={ 'slug': {'fields': ['slug']}, 'writer': {'fields': ['info__writers__contains']}, 'medal': {'fields': ['info__standings__medals'], 'suff': '__isnull', 'func': lambda v: False}, }, logger=request.logger)) context = { 'contests': contests, 'timezone': get_timezone(request), 'timeformat': get_timeformat(request), 'all_standings': all_standings, 'switch': switch, } if extra_context is not None: context.update(extra_context) return render(request, template, context)
def standings_list(request, template='standings_list.html', extra_context=None): contests = Contest.objects \ .select_related('timing') \ .annotate(has_statistics=Exists(Statistics.objects.filter(contest=OuterRef('pk')))) \ .annotate(has_module=Exists(Module.objects.filter(resource=OuterRef('resource_id')))) \ .filter(Q(has_statistics=True) | Q(end_time__lte=timezone.now())) \ .order_by('-end_time', 'pk') has_perm_reset_statistic_timing = False all_standings = False if request.user.is_authenticated: all_standings = request.user.coder.settings.get('all_standings') has_perm_reset_statistic_timing = request.user.has_perm( 'reset_contest_statistic_timing') switch = 'switch' in request.GET if bool(all_standings) == bool(switch): contests = contests.filter(has_statistics=True, has_module=True) if request.user.is_authenticated: contests = contests.filter( request.user.coder.get_contest_filter(['list'])) search = request.GET.get('search') if search is not None: contests = contests.filter( get_iregex_filter(search, 'title', 'resource__host')) context = { 'contests': contests, 'timezone': get_timezone(request), 'timeformat': get_timeformat(request), 'all_standings': all_standings, 'has_perm_reset_statistic_timing': has_perm_reset_statistic_timing, 'switch': switch, } if extra_context is not None: context.update(extra_context) return render(request, template, context)
def standings(request, title_slug=None, contest_id=None, template='standings.html', extra_context=None): context = {} groupby = request.GET.get('groupby') if groupby == 'none': groupby = None search = request.GET.get('search') if search == '': url = request.get_full_path() url = re.sub('search=&?', '', url) url = re.sub(r'\?$', '', url) return redirect(url) orderby = request.GET.getlist('orderby') if orderby: if '--' in orderby: updated_orderby = [] else: orderby_set = set() unique_orderby = reversed([ f for k, f in [(f.lstrip('-'), f) for f in reversed(orderby)] if k not in orderby_set and not orderby_set.add(k) ]) updated_orderby = [ f for f in unique_orderby if not f.startswith('--') ] if updated_orderby != orderby: query = request.GET.copy() query.setlist('orderby', updated_orderby) return redirect(f'{request.path}?{query.urlencode()}') contests = Contest.objects to_redirect = False contest = None if contest_id is not None: contest = contests.filter(pk=contest_id).first() if title_slug is None: to_redirect = True else: if contest is None or slug(contest.title) != title_slug: contest = None title_slug += f'-{contest_id}' if contest is None and title_slug is not None: contests_iterator = contests.filter(slug=title_slug).iterator() contest = None try: contest = next(contests_iterator) another = next(contests_iterator) except StopIteration: another = None if contest is None: return HttpResponseNotFound() if another is None: to_redirect = True else: return redirect( reverse('ranking:standings_list') + f'?search=slug:{title_slug}') if contest is None: return HttpResponseNotFound() if to_redirect: query = query_transform(request) url = reverse('ranking:standings', kwargs={ 'title_slug': slug(contest.title), 'contest_id': str(contest.pk) }) if query: query = '?' + query return redirect(url + query) with_detail = request.GET.get('detail', 'true') in ['true', 'on'] if request.user.is_authenticated: coder = request.user.coder if 'detail' in request.GET: coder.settings['standings_with_detail'] = with_detail coder.save() else: with_detail = coder.settings.get('standings_with_detail', False) else: coder = None with_row_num = False contest_fields = list(contest.info.get('fields', [])) hidden_fields = list(contest.info.get('hidden_fields', [])) statistics = Statistics.objects.filter(contest=contest) options = contest.info.get('standings', {}) order = None resource_standings = contest.resource.info.get('standings', {}) order = copy.copy(options.get('order', resource_standings.get('order'))) if order: for f in order: if f.startswith('addition__') and f.split( '__', 1)[1] not in contest_fields: order = None break if order is None: order = ['place_as_int', '-solving'] # fixed fields fixed_fields = ( ('penalty', 'Penalty'), ('total_time', 'Time'), ('advanced', 'Advance'), ) fixed_fields += tuple(options.get('fixed_fields', [])) if not with_detail: fixed_fields += (('rating_change', 'Rating change'), ) statistics = statistics \ .select_related('account') \ .select_related('account__resource') \ .prefetch_related('account__coders') has_country = ('country' in contest_fields or '_countries' in contest_fields or statistics.filter(account__country__isnull=False).exists()) division = request.GET.get('division') if division == 'any': with_row_num = True if 'place_as_int' in order: order.remove('place_as_int') order.append('place_as_int') fixed_fields += (('division', 'Division'), ) if 'team_id' in contest_fields and not groupby: order.append('addition__name') statistics = statistics.distinct(*[f.lstrip('-') for f in order]) # host = resource_standings.get('account_team_resource', contest.resource.host) # account_team_resource = Resource.objects.get(host=host) # context['account_team_resource'] = account_team_resource # statistics = statistics.annotate( # accounts=RawSQL( # ''' # SELECT array_agg(array[u2.key, u3.rating::text, u3.url]) # FROM "ranking_statistics" U0 # INNER JOIN "ranking_account" U2 # ON (u0."account_id" = u2."id") # INNER JOIN "ranking_account" U3 # ON (u2."key" = u3."key" AND u3."resource_id" = %s) # WHERE ( # u0."contest_id" = %s # AND ("u0"."addition" -> 'team_id') = ("ranking_statistics"."addition" -> 'team_id') # ) # ''', # [account_team_resource.pk, contest.pk] # ) # ) order.append('pk') statistics = statistics.order_by(*order) fields = OrderedDict() for k, v in fixed_fields: if k in contest_fields: fields[k] = v n_highlight_context = _standings_highlight(statistics, options) # field to select fields_to_select_defaults = { 'rating': { 'options': ['rated', 'unrated'], 'noajax': True, 'nomultiply': True, 'nourl': True }, 'advanced': { 'options': ['true', 'false'], 'noajax': True, 'nomultiply': True }, 'highlight': { 'options': ['true', 'false'], 'noajax': True, 'nomultiply': True }, } fields_to_select = OrderedDict() map_fields_to_select = {'rating_change': 'rating'} for f in sorted(contest_fields): f = f.strip('_') if f.lower() in [ 'institution', 'room', 'affiliation', 'city', 'languages', 'school', 'class', 'job', 'region', 'rating_change', 'advanced', 'company', 'language', 'league', 'onsite', 'degree', 'university', 'list', ]: f = map_fields_to_select.get(f, f) field_to_select = fields_to_select.setdefault(f, {}) field_to_select['values'] = [ v for v in request.GET.getlist(f) if v ] field_to_select.update(fields_to_select_defaults.get(f, {})) if n_highlight_context.get('statistics_ids'): f = 'highlight' field_to_select = fields_to_select.setdefault(f, {}) field_to_select['values'] = [v for v in request.GET.getlist(f) if v] field_to_select.update(fields_to_select_defaults.get(f, {})) chats = coder.chats.all() if coder else None if chats: options_values = {c.chat_id: c.title for c in chats} fields_to_select['chat'] = { 'values': [ v for v in request.GET.getlist('chat') if v and v in options_values ], 'options': options_values, 'noajax': True, 'nogroupby': True, 'nourl': True, } hidden_fields_values = [v for v in request.GET.getlist('field') if v] for v in hidden_fields_values: if v not in hidden_fields: hidden_fields.append(v) for k in contest_fields: if (k in fields or k in [ 'problems', 'team_id', 'solved', 'hack', 'challenges', 'url', 'participant_type', 'division' ] or k == 'medal' and '_medal_title_field' in contest_fields or 'country' in k and k not in hidden_fields_values or k in ['name'] and k not in hidden_fields_values or k.startswith('_') or k in hidden_fields and k not in hidden_fields_values): continue if with_detail or k in hidden_fields_values: fields[k] = k else: hidden_fields.append(k) for k, field in fields.items(): if k != field: continue field = ' '.join(k.split('_')) if field and not field[0].isupper(): field = field.title() fields[k] = field if hidden_fields: fields_to_select['field'] = { 'values': hidden_fields_values, 'options': hidden_fields, 'noajax': True, 'nogroupby': True, 'nourl': True, 'nofilter': True, } per_page = options.get('per_page', 50) if per_page is None: per_page = 100500 elif contest.n_statistics and contest.n_statistics < 500: per_page = contest.n_statistics mod_penalty = {} first = statistics.first() if first and all('time' not in k for k in contest_fields): penalty = first.addition.get('penalty') if penalty and isinstance(penalty, int) and 'solved' not in first.addition: mod_penalty.update({'solving': first.solving, 'penalty': penalty}) params = {} problems = contest.info.get('problems', {}) if 'division' in problems: divisions_order = list( problems.get('divisions_order', sorted(contest.info['problems']['division'].keys()))) elif 'divisions_order' in contest.info: divisions_order = contest.info['divisions_order'] else: divisions_order = [] if divisions_order: divisions_order.append('any') if division not in divisions_order: division = divisions_order[0] params['division'] = division if 'division' in problems: if division == 'any': _problems = OrderedDict() for div in reversed(divisions_order): for p in problems['division'].get(div, []): k = get_problem_short(p) if k not in _problems: _problems[k] = p else: for f in 'n_accepted', 'n_teams', 'n_partial', 'n_total': if f in p: _problems[k][f] = _problems[k].get( f, 0) + p[f] problems = list(_problems.values()) else: problems = problems['division'][division] if division != 'any': statistics = statistics.filter(addition__division=division) for p in problems: if 'full_score' in p and isinstance( p['full_score'], (int, float)) and abs(p['full_score'] - 1) > 1e-9: mod_penalty = {} break last = None merge_problems = False for p in problems: if last and (last.get('full_score') or last.get('subname')) and ( 'name' in last and last.get('name') == p.get('name') or 'group' in last and last.get('group') == p.get('group')): merge_problems = True last['colspan'] = last.get('colspan', 1) + 1 p['skip'] = True else: last = p last['colspan'] = 1 # own_stat = statistics.filter(account__coders=coder).first() if coder else None # filter by search search = request.GET.get('search') if search: with_row_num = True if search.startswith('party:'): _, party_slug = search.split(':') party = get_object_or_404(Party.objects.for_user(request.user), slug=party_slug) statistics = statistics.filter( Q(account__coders__in=party.coders.all()) | Q(account__coders__in=party.admins.all()) | Q(account__coders=party.author)) else: cond = get_iregex_filter(search, 'account__key', 'addition__name', logger=request.logger) statistics = statistics.filter(cond) # filter by country countries = request.GET.getlist('country') countries = set([c for c in countries if c]) if countries: with_row_num = True cond = Q(account__country__in=countries) if 'None' in countries: cond |= Q(account__country__isnull=True) if '_countries' in contest_fields: for code in countries: name = get_country_name(code) if name: cond |= Q(addition___countries__icontains=name) statistics = statistics.filter(cond) params['countries'] = countries # filter by field to select for field, field_to_select in fields_to_select.items(): values = field_to_select.get('values') if not values or field_to_select.get('nofilter'): continue with_row_num = True filt = Q() if field == 'languages': for lang in values: if lang == 'any': filt = Q(**{'addition___languages__isnull': False}) break filt |= Q(**{'addition___languages__contains': [lang]}) elif field == 'rating': for q in values: if q not in field_to_select['options']: continue q = q == 'unrated' if q: filt |= Q(addition__rating_change__isnull=True) & Q( addition__new_rating__isnull=True) else: filt |= Q(addition__rating_change__isnull=False) | Q( addition__new_rating__isnull=False) elif field == 'advanced': for q in values: if q not in field_to_select['options']: continue filt |= Q(addition__advanced=q == 'true') elif field == 'highlight': for q in values: if q not in field_to_select['options']: continue filt = Q(pk__in=n_highlight_context.get('statistics_ids', {})) if q == 'false': filt = ~filt elif field == 'chat': for q in values: if q not in field_to_select['options']: continue chat = Chat.objects.filter(chat_id=q, is_group=True).first() if chat: filt |= Q(account__coders__in=chat.coders.all()) # subquery = Chat.objects.filter(coder=OuterRef('account__coders'), is_group=False).values('name')[:1] # statistics = statistics.annotate(chat_name=Subquery(subquery)) else: query_field = f'addition__{field}' statistics = statistics.annotate(**{ f'{query_field}_str': Cast(JSONF(query_field), models.TextField()) }) for q in values: if q == 'None': filt |= Q(**{f'{query_field}__isnull': True}) else: filt |= Q(**{f'{query_field}_str': q}) statistics = statistics.filter(filt) # groupby if groupby == 'country' or groupby in fields_to_select: statistics = statistics.order_by('pk') participants_info = n_highlight_context.get('participants_info') n_highlight = options.get('n_highlight') advanced_by_participants_info = participants_info and n_highlight and groupby != 'languages' fields = OrderedDict() fields['groupby'] = groupby.title() fields['n_accounts'] = 'Num' fields['avg_score'] = 'Avg' medals = {m['name']: m for m in options.get('medals', [])} if 'medal' in contest_fields: for medal in settings.ORDERED_MEDALS_: fields[f'n_{medal}'] = medals.get(medal, {}).get( 'value', medal[0].upper()) if 'advanced' in contest_fields or advanced_by_participants_info: fields['n_advanced'] = 'Adv' orderby = [f for f in orderby if f.lstrip('-') in fields ] or ['-n_accounts', '-avg_score'] if groupby == 'languages': _, before_params = statistics.query.sql_with_params() querysets = [] for problem in problems: key = get_problem_short(problem) field = f'addition__problems__{key}__language' score = f'addition__problems__{key}__result' qs = statistics \ .filter(**{f'{field}__isnull': False, f'{score}__isnull': False}) \ .annotate(language=Cast(JSONF(field), models.TextField())) \ .annotate(score=Case( When(**{f'{score}__startswith': '+'}, then=1), When(**{f'{score}__startswith': '-'}, then=0), When(**{f'{score}__startswith': '?'}, then=0), default=Cast(JSONF(score), models.FloatField()), output_field=models.FloatField(), )) \ .annotate(sid=F('pk')) querysets.append(qs) merge_statistics = querysets[0].union(*querysets[1:], all=True) language_query, language_params = merge_statistics.query.sql_with_params( ) field = 'solving' statistics = statistics.annotate(groupby=F(field)) elif groupby == 'rating': statistics = statistics.annotate(groupby=Case( When(addition__rating_change__isnull=False, then=Value('Rated')), default=Value('Unrated'), output_field=models.TextField(), )) elif groupby == 'country': if '_countries' in contest_fields: statistics = statistics.annotate(country=RawSQL( '''json_array_elements((("addition" ->> '_countries'))::json)::jsonb''', [])) field = 'country' else: field = 'account__country' statistics = statistics.annotate(groupby=F(field)) else: field = f'addition__{groupby}' types = contest.info.get('fields_types', {}).get(groupby, []) if 'int' in types: field_type = models.IntegerField() elif 'float' in types: field_type = models.FloatField() else: field_type = models.TextField() statistics = statistics.annotate( groupby=Cast(JSONF(field), field_type)) statistics = statistics.order_by('groupby') statistics = statistics.values('groupby') statistics = statistics.annotate(n_accounts=Count('id')) statistics = statistics.annotate(avg_score=Avg('solving')) if 'medal' in contest_fields: for medal in settings.ORDERED_MEDALS_: n_medal = f'n_{medal}' statistics = statistics.annotate( **{ f'{n_medal}': Count(Case(When(addition__medal__iexact=medal, then=1))) }) if 'advanced' in contest_fields: statistics = statistics.annotate(n_advanced=Count( Case( When(addition__advanced=True, then=1), When(~Q(addition__advanced=False) & ~Q(addition__advanced=''), then=1), ))) elif advanced_by_participants_info: pks = list() for pk, info in participants_info.items(): if 'n' not in info or info['n'] > info.get( 'n_highlight', n_highlight): continue pks.append(pk) statistics = statistics.annotate( n_advanced=Count(Case(When(pk__in=set(pks), then=1)))) statistics = statistics.order_by(*orderby) if groupby == 'languages': query, sql_params = statistics.query.sql_with_params() query = query.replace( f'"ranking_statistics"."{field}" AS "groupby"', '"language" AS "groupby"') query = query.replace(f'GROUP BY "ranking_statistics"."{field}"', 'GROUP BY "language"') query = query.replace('"ranking_statistics".', '') query = query.replace('AVG("solving") AS "avg_score"', 'AVG("score") AS "avg_score"') query = query.replace('COUNT("id") AS "n_accounts"', 'COUNT("sid") AS "n_accounts"') query = re.sub('FROM "ranking_statistics".*GROUP BY', f'FROM ({language_query}) t1 GROUP BY', query) sql_params = sql_params[:-len(before_params)] + language_params with connection.cursor() as cursor: cursor.execute(query, sql_params) columns = [col[0] for col in cursor.description] statistics = [ dict(zip(columns, row)) for row in cursor.fetchall() ] statistics = ListAsQueryset(statistics) problems = [] labels_groupby = { 'n_accounts': 'Number of participants', 'avg_score': 'Average score', 'n_advanced': 'Number of advanced', } for medal in settings.ORDERED_MEDALS_: labels_groupby[f'n_{medal}'] = 'Number of ' + medals.get( medal, {}).get('value', medal) num_rows_groupby = statistics.count() map_colors_groupby = { s['groupby']: idx for idx, s in enumerate(statistics) } else: groupby = 'none' labels_groupby = None num_rows_groupby = None map_colors_groupby = None my_statistics = [] if groupby == 'none' and coder: statistics = statistics.annotate( my_stat=SubqueryExists('account__coders', filter=Q(coder=coder))) my_statistics = statistics.filter(account__coders=coder).extra( select={'floating': True}) context.update({ 'standings_options': options, 'mod_penalty': mod_penalty, 'colored_by_group_score': mod_penalty or options.get('colored_by_group_score'), 'contest': contest, 'statistics': statistics, 'my_statistics': my_statistics, 'problems': problems, 'params': params, 'fields': fields, 'fields_types': contest.info.get('fields_types', {}), 'divisions_order': divisions_order, 'has_country': has_country, 'per_page': per_page, 'with_row_num': with_row_num, 'merge_problems': merge_problems, 'fields_to_select': fields_to_select, 'truncatechars_name_problem': 10 * (2 if merge_problems else 1), 'with_detail': with_detail, 'groupby': groupby, 'pie_limit_rows_groupby': 50, 'labels_groupby': labels_groupby, 'num_rows_groupby': num_rows_groupby, 'map_colors_groupby': map_colors_groupby, 'advance': contest.info.get('advance'), 'timezone': get_timezone(request), 'timeformat': get_timeformat(request), 'with_neighbors': request.GET.get('neighbors') == 'on', 'with_table_inner_scroll': not request.user_agent.is_mobile, }) context.update(n_highlight_context) if extra_context is not None: context.update(extra_context) return render(request, template, context)
def event(request, slug, tab=None, template='event.html', extra_context=None): event = get_object_or_404(Event, slug=slug) if tab is not None and tab not in [ 'information', 'registration', 'teams', 'participants', 'admin' ]: return HttpResponseNotFound() user = request.user coder = None if user.is_anonymous else user.coder participant = event.participant_set.filter(coder=coder, coder__isnull=False).first() if participant: join_requests = participant.joinrequest_set.all() team = event.team_set \ .filter(participants__pk=participant.pk) \ .prefetch_related('joinrequest_set', 'participants') \ .first() else: join_requests = None team = None has_join_requests = join_requests is not None and join_requests.exists() end_registration = event.registration_deadline < now() registration_timeleft = event.registration_deadline - now() if coder and coder.settings.get('unlimited_deadline'): registration_timeleft = timedelta(minutes=42) end_registration = False query = request.POST.get('query') or request.GET.get('query') if query is not None and not end_registration and coder: if not request.META.get('HTTP_REFERER'): return redirect( resolve_url('events:event-tab', slug=event.slug, tab='registration')) if query == 'skip-coach': if not team or team.author != participant: messages.error(request, 'First you need to create a team') elif team.status != TeamStatus.ADD_COACH: messages.error(request, 'Not necessary skip coach') else: team.status = TeamStatus.PENDING team.save() elif query in ['join', 'add-coach']: # 'join-as-coach' is_coach = query == 'add-coach' ok = True if not is_coach and participant: messages.info(request, 'You have already joined the event') ok = False if is_coach and (not team or team.status != TeamStatus.ADD_COACH): messages.error(request, 'First you need to create a team') ok = False else: active_fields = [ 'first-name', 'last-name', 'email', 'first-name-native', 'last-name-native', 'phone-number', 'tshirt-size', ] if not is_coach: active_fields.append('date-of-birth') active_fields.append('organization') active_fields.append('country') for field in event.fields_info.get('addition_fields', []): active_fields.append(field['name']) active_fields = [ f for f in active_fields if f not in event.fields_info.get('disabled_fields', []) ] for field in active_fields: if not request.POST.get(field, ''): messages.error(request, 'You must specify all the information') ok = False break else: if not is_coach and not coder.token_set.filter( email=request.POST['email']).exists(): messages.error( request, 'Invalid email. Check that the account with this email is connected' ) ok = False active_fields.append('middle-name-native') if 'phone-number' in active_fields: try: phone_number = PhoneNumber.from_string( phone_number=request.POST.get('phone-number')) assert phone_number.is_valid() except Exception: messages.error(request, 'Invalid phone number') ok = False handle = request.POST.get('codeforces-handle') if handle and not is_coach: error = None resource = Resource.objects.get(host='codeforces.com') account = Account.objects.filter( key=handle, resource=resource).first() if not account: error = f'Codeforces handle {handle} not found' elif coder.account_set.filter(resource=resource).exists(): error = f'Codeforces handle {handle} is already connect' else: module = Module.objects.filter( resource=resource).first() if not module or not module.multi_account_allowed: if coder.account_set.filter( resource=resource).exists(): error = 'Allow only one account for this resource' elif account.coders.count(): error = 'Account is already connect' if error: messages.error(request, error) ok = False else: account.coders.add(coder) account.save() if is_coach: participant = Participant.objects.create(event=event, is_coach=True) else: participant, _ = Participant.objects.get_or_create(coder=coder, event=event) org_created = False try: data = dict(list(request.POST.items())) for field in active_fields: if data.get(field): data[field] = data[field].strip() if 'phone-number' in active_fields: data['phone-number'] = phone_number.as_e164 if 'tshirt-size' in active_fields: data['tshirt-size'] = int(data['tshirt-size']) if not is_coach and 'organization' in data: organization_name = data['organization'] organization, org_created = Organization.objects.get_or_create( name=organization_name) if org_created: organization.name_ru = organization_name organization.author = coder organization.save() data['organization'] = organization for object_, attr in ( (user, 'first_name'), (user, 'last_name'), (user, 'email'), (coder, 'first_name_native'), (coder, 'last_name_native'), (coder, 'middle_name_native'), (coder, 'phone_number'), (coder, 'country'), (coder, 'date_of_birth'), (coder, 'organization'), (coder, 'tshirt_size'), ): field = attr.replace('_', '-') if field not in active_fields: continue value = data[field] setattr(participant, attr, value) if not is_coach and object_: if attr == 'tshirt_size': value = participant.tshirt_size_value setattr(object_, attr, value or getattr(object_, attr)) for field in event.fields_info.get('addition_fields', []): field = field['name'] if field not in active_fields: continue value = data[field] coder.addition_fields[field] = value participant.addition_fields[field] = value participant.save() user.save() coder.save() if is_coach: team.coach = participant team.status = TeamStatus.PENDING team.save() except Exception as e: messages.error(request, str(e)) ok = False if not ok: participant.delete() if org_created: organization.delete() elif query == 'create-team': team_name = request.POST.get('team') team_name_limit = event.limits.get('team_name_length') if not team_name: messages.error(request, 'You must specify team name') elif team_name_limit and len(team_name) > team_name_limit: messages.error( request, f'The team name is too long (limit is {team_name_limit})') elif participant and participant.is_coach: team = Team.objects.create(event=event, name=team_name, author=participant) team.coach = participant team.save() elif team or has_join_requests: messages.error(request, 'You have already committed an action') else: team = Team.objects.create(event=event, name=team_name, author=participant) team.participants.add(participant) team.save() elif query == 'join-team': is_coach = participant and participant.is_coach if not is_coach and (team or has_join_requests): messages.error(request, 'You have already committed an action') else: team_id = int(request.POST.get('team')) team = Team.objects.get(pk=team_id, event=event, status=TeamStatus.NEW) if not JoinRequest.objects.filter( team=team, participant=participant).exists(): JoinRequest.objects.create(team=team, participant=participant) elif query == 'cancel-request': if not has_join_requests: messages.error(request, 'Join request not found') else: join_request_id = int(request.GET.get('request_id')) JoinRequest.objects.filter(pk=join_request_id, participant=participant).delete() elif query in ['accept-team', 'reject-team']: request_id = int(request.POST.get('request_id')) join_request = JoinRequest.objects \ .filter(pk=request_id) \ .filter(Q(team__author=participant) | Q(team__coach=participant)) \ .first() if not join_request: messages.error(request, 'First you need to create a join request') else: participant = join_request.participant team = join_request.team if query == 'accept-team': if participant.is_coach: if team.coach: messages.error(request, 'Team already has coach') else: team.coach = participant team.save() join_request.delete() else: if team.participants.count() >= event.team_size: messages.error(request, 'Too many team participants') else: team.participants.add(participant) join_request.delete() elif query in ['register', 'delete-team']: team_id = int(request.POST.get('team_id')) team = Team.objects \ .filter(pk=team_id) \ .filter(Q(author=participant) | Q(coach=participant)) \ .first() if not team: messages.error(request, 'First you need to create a team') elif team.status != TeamStatus.NEW: messages.error(request, 'Team already registered') elif query == 'delete-team': team.delete() elif not 0 < team.participants.count() <= event.team_size: messages.error( request, 'Team should be consists of one to three participants') else: if team.coach: team.status = TeamStatus.PENDING else: team.status = TeamStatus.ADD_COACH team.save() elif query == 'cancel-registration': if has_join_requests: request.logger.error( 'Cancel join requests before cancel registration') elif team: request.logger.error('Remove team before cancel registration') elif not participant: request.logger.error('Register before cancel registration') else: participant.delete() elif query == 'looking-for': if has_join_requests: request.logger.error('Cancel join requests') elif team: request.logger.error('Remove team before') elif not participant: request.logger.error('Register before') else: participant.looking_for = not participant.looking_for participant.save() else: request.logger.error(f'Unknown query "{query}"') return redirect( resolve_url('events:event-tab', slug=event.slug, tab='registration')) teams = Team.objects.filter(event=event).order_by('-modified') teams = teams.prefetch_related( 'participants__coder__user', 'participants__organization', ) teams = teams.select_related( 'author__coder__user', 'author__organization', 'coach__coder__user', 'coach__organization', ) codeforces_resource = Resource.objects.get(host='codeforces.com') teams = teams.prefetch_related( Prefetch( 'participants__coder__account_set', queryset=Account.objects.filter(resource=codeforces_resource), ), 'participants__coder__account_set__resource', ) approved_statuses = { k for k, v in TeamStatus.descriptions.items() if v in ['approved', 'disqualified'] } team_search = request.GET.get('team_search') if team_search: team_search_filter = get_iregex_filter( team_search, 'name', 'participants__first_name', 'participants__last_name', 'participants__organization__name', 'participants__organization__abbreviation', 'coach__first_name', 'coach__last_name', 'coach__organization__name', 'coach__organization__abbreviation', ) teams = teams.filter(team_search_filter) team_participants = teams.filter(status__in=approved_statuses) participants = Participant.objects.filter( event=event, is_coach=False, ).filter(Q(team=None) | Q(team__status=TeamStatus.NEW), ) participant_search = request.GET.get('participant_search') if participant_search: participant_search_filter = get_iregex_filter( participant_search, 'first_name', 'last_name', 'organization__name', 'organization__abbreviation', 'team__name', ) participants = participants.filter(participant_search_filter) qs = Participant.objects.filter(team__isnull=False).order_by('-created') qs = qs.prefetch_related('team__participants').select_related( 'team__author') participants = participants.prefetch_related( Prefetch('coder__participant_set', queryset=qs)).order_by('-modified') status = request.GET.get('status') if status is not None: teams = teams.filter(status=status) context = { 'slug': slug, 'event': event, 'tab': tab, 'svg_r': 5, 'coder': coder, 'participant': participant, 'team_participants': team_participants, 'participants': participants, 'team': team, 'join_requests': join_requests, 'team_status': TeamStatus, 'tshirt_size': TshirtSize, 'teams': teams, 'timezone': get_timezone(request), 'timeformat': get_timeformat(request), 'defaults': { 'country': { 'code': 'BY', 'name': dict(countries)['BY'] }, }, 'registration': { 'over': end_registration, 'timeleft': humanfriendly.format_timespan(registration_timeleft), }, 'codeforces_resource': codeforces_resource, } if extra_context is not None: context.update(extra_context) return render(request, template, context)
def get_profile_context(request, statistics, writers): history_resources = statistics \ .filter(contest__resource__has_rating_history=True) \ .filter(contest__stage__isnull=True) \ .annotate(new_rating=Cast(KeyTextTransform('new_rating', 'addition'), IntegerField())) \ .filter(new_rating__isnull=False) \ .annotate(host=F('contest__resource__host')) \ .values('host') \ .annotate(num_contests=Count('contest')) \ .order_by('-num_contests') stats = statistics \ .select_related('contest', 'account') \ .filter(addition__medal__isnull=False) \ .order_by('-contest__end_time') resource_medals = {} account_medals = {} for stat in stats: resource_medals.setdefault(stat.contest.resource_id, []).append(stat) account_medals.setdefault(stat.account.id, []).append(stat) statistics = statistics \ .select_related('contest', 'contest__resource', 'account') \ .order_by('-contest__end_time') search = request.GET.get('search') filters = {} if search: filt = get_iregex_filter( search, 'contest__resource__host', 'contest__title', mapping={ 'writer': { 'fields': ['contest__info__writers__contains'] }, 'contest': { 'fields': ['contest__title__iregex'] }, 'resource': { 'fields': ['contest__resource__host'] }, 'account': { 'fields': ['account__key'] }, 'medal': { 'fields': ['addition__medal'], 'func': lambda v: False if not v or v == 'any' else v, 'suff': lambda v: '__isnull' if v is False else '', }, 'cid': { 'fields': ['contest_id'], 'func': lambda v: int(v) }, 'rid': { 'fields': ['contest__resource_id'], 'func': lambda v: int(v) }, }, values=filters, logger=request.logger, ) statistics = statistics.filter(filt) filter_resources = filters.pop('resource', []) for val in filter_resources: history_resources = history_resources.filter( contest__resource__host=val) search_resource = filter_resources[0] if len( filter_resources) == 1 else None if search_resource: writers = writers.filter(resource__host=search_resource) writers = writers.order_by('-end_time') writers = writers.annotate(has_statistics=Exists('statistics')) context = { 'statistics': statistics, 'writers': writers, 'history_resources': history_resources, 'show_history_ratings': not filters, 'resource_medals': resource_medals, 'account_medals': account_medals, 'search_resource': search_resource, 'timezone': get_timezone(request), 'timeformat': get_timeformat(request), } return context
def coder_time_info(request): return { 'timeformat': get_timeformat(request), 'timezone': get_timezone(request), }