lib/Gruntmaster/Data/Result/Contest.pm

   1 use utf8;
   2 package Gruntmaster::Data::Result::Contest;
   3
   4 # Created by DBIx::Class::Schema::Loader
   5 # DO NOT MODIFY THE FIRST PART OF THIS FILE
   6
   7 =head1 NAME
   8
   9 Gruntmaster::Data::Result::Contest
  10
  11 =cut
  12
  13 use strict;
  14 use warnings;
  15
  16 use base 'DBIx::Class::Core';
  17
  18 =head1 TABLE: C<contests>
  19
  20 =cut
  21
  22 __PACKAGE__->table("contests");
  23
  24 =head1 ACCESSORS
  25
  26 =head2 id
  27
  28   data_type: 'text'
  29   is_nullable: 0
  30
  31 =head2 name
  32
  33   data_type: 'text'
  34   is_nullable: 0
  35
  36 =head2 start
  37
  38   data_type: 'integer'
  39   is_nullable: 0
  40
  41 =head2 stop
  42
  43   data_type: 'integer'
  44   is_nullable: 0
  45
  46 =head2 owner
  47
  48   data_type: 'text'
  49   is_foreign_key: 1
  50   is_nullable: 0
  51
  52 =cut
  53
  54 __PACKAGE__->add_columns(
  55   "id",
  56   { data_type => "text", is_nullable => 0 },
  57   "name",
  58   { data_type => "text", is_nullable => 0 },
  59   "start",
  60   { data_type => "integer", is_nullable => 0 },
  61   "stop",
  62   { data_type => "integer", is_nullable => 0 },
  63   "owner",
  64   { data_type => "text", is_foreign_key => 1, is_nullable => 0 },
  65 );
  66
  67 =head1 PRIMARY KEY
  68
  69 =over 4
  70
  71 =item * L</id>
  72
  73 =back
  74
  75 =cut
  76
  77 __PACKAGE__->set_primary_key("id");
  78
  79 =head1 RELATIONS
  80
  81 =head2 contest_problems
  82
  83 Type: has_many
  84
  85 Related object: L<Gruntmaster::Data::Result::ContestProblem>
  86
  87 =cut
  88
  89 __PACKAGE__->has_many(
  90   "contest_problems",
  91   "Gruntmaster::Data::Result::ContestProblem",
  92   { "foreign.contest" => "self.id" },
  93   { cascade_copy => 0, cascade_delete => 0 },
  94 );
  95
  96 =head2 contest_statuses
  97
  98 Type: has_many
  99
 100 Related object: L<Gruntmaster::Data::Result::ContestStatus>
 101
 102 =cut
 103
 104 __PACKAGE__->has_many(
 105   "contest_statuses",
 106   "Gruntmaster::Data::Result::ContestStatus",
 107   { "foreign.contest" => "self.id" },
 108   { cascade_copy => 0, cascade_delete => 0 },
 109 );
 110
 111 =head2 jobs
 112
 113 Type: has_many
 114
 115 Related object: L<Gruntmaster::Data::Result::Job>
 116
 117 =cut
 118
 119 __PACKAGE__->has_many(
 120   "jobs",
 121   "Gruntmaster::Data::Result::Job",
 122   { "foreign.contest" => "self.id" },
 123   { cascade_copy => 0, cascade_delete => 0 },
 124 );
 125
 126 =head2 opens
 127
 128 Type: has_many
 129
 130 Related object: L<Gruntmaster::Data::Result::Open>
 131
 132 =cut
 133
 134 __PACKAGE__->has_many(
 135   "opens",
 136   "Gruntmaster::Data::Result::Open",
 137   { "foreign.contest" => "self.id" },
 138   { cascade_copy => 0, cascade_delete => 0 },
 139 );
 140
 141 =head2 owner
 142
 143 Type: belongs_to
 144
 145 Related object: L<Gruntmaster::Data::Result::User>
 146
 147 =cut
 148
 149 __PACKAGE__->belongs_to(
 150   "owner",
 151   "Gruntmaster::Data::Result::User",
 152   { id => "owner" },
 153   { is_deferrable => 0, on_delete => "CASCADE", on_update => "NO ACTION" },
 154 );
 155
 156 =head2 problems
 157
 158 Type: many_to_many
 159
 160 Composing rels: L</contest_problems> -> problem
 161
 162 =cut
 163
 164 __PACKAGE__->many_to_many("problems", "contest_problems", "problem");
 165
 166
 167 # Created by DBIx::Class::Schema::Loader v0.07042 @ 2014-12-11 23:51:27
 168 # DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:nu+Io9AhYkzYCky5UpCaKQ
 169
 170 use List::Util qw/sum/;
 171
 172 sub is_pending {
 173         my ($self, $time) = @_;
 174         $self->start > ($time // time)
 175 }
 176
 177 sub is_finished {
 178         my ($self, $time) = @_;
 179         $self->stop <= ($time // time)
 180 }
 181
 182 sub is_running {
 183         my ($self, $time) = @_;
 184         !$self->is_pending($time) && !$self->is_finished($time)
 185 }
 186
 187 sub calc_score{
 188         my ($mxscore, $time, $tries, $totaltime) = @_;
 189         my $score = $mxscore;
 190         $time = 0 if $time < 0;
 191         $time = 300 if $time > $totaltime;
 192         $score = ($totaltime - $time) / $totaltime * $score;
 193         $score -= $tries / 10 * $mxscore;
 194         $score = $mxscore * 3 / 10 if $score < $mxscore * 3 / 10;
 195         int $score + 0.5
 196 }
 197
 198 sub standings {
 199         my ($self) = @_;
 200         my $ct = $self->id;
 201
 202         my @problems = map { $_->rawproblem } $self->contest_problems->search({contest => $ct}, {qw/join problem order_by problem.level/});
 203         my (%scores, %tries, %opens);
 204         $opens{$_->rawproblem, $_->rawowner} = $_ for $self->opens->search({contest => $ct});
 205         for my $job ($self->jobs->search({contest => $ct}, {qw/order_by me.id prefetch/ => [qw/problem/]})) {
 206                 my $open = $opens{$job->rawproblem, $job->rawowner};
 207                 my $time = $job->date - ($open ? $open->time : $self->start);
 208                 next if $time < 0;
 209                 my $value = $job->problem->value;
 210                 my $factor = $job->result ? 0 : 1;
 211                 $factor = $1 / 100 if $job->result_text =~ /^(\d+ )/s;
 212                 $scores{$job->rawowner}{$job->rawproblem} = int ($factor * calc_score ($value, $time, $tries{$job->rawowner}{$job->rawproblem}++, $self->stop - $self->start));
 213         }
 214
 215         my %user_to_name = map { $_ => $_->name } $self->result_source->schema->users->all;
 216
 217         my @st = sort { $b->{score} <=> $a->{score} or $a->{user} cmp $b->{user} } map { ## no critic (ProhibitReverseSortBlock)
 218                 my $user = $_;
 219                 +{
 220                         user => $user,
 221                         user_name => $user_to_name{$user},
 222                         score => sum (values %{$scores{$user}}),
 223                         scores => [map { $scores{$user}{$_} // '-'} @problems],
 224                 }
 225         } keys %scores;
 226
 227         $st[0]->{rank} = 1;
 228         $st[$_]->{rank} = $st[$_ - 1]->{rank} + ($st[$_]->{score} < $st[$_ - 1]->{score}) for 1 .. $#st;
 229         @st
 230 }
 231
 232 1;
 233
 234 __END__
 235
 236 =head1 METHODS
 237
 238 =head2 is_pending(I<[$time]>)
 239
 240 Returns true if the contest is pending at time I<$time> (which defaults to C<time>).
 241
 242 =head2 is_finished(I<[$time]>)
 243
 244 Returns true if the contest is finished at time I<$time> (which defaults to C<time>).
 245
 246 =head2 is_running(I<[$time]>)
 247
 248 Returns true if the contest is running at time I<$time> (which defaults to C<time>).
 249
 250 =head1 AUTHOR
 251
 252 Marius Gavrilescu E<lt>marius@ieval.roE<gt>
 253
 254 =head1 COPYRIGHT AND LICENSE
 255
 256 Copyright (C) 2014 by Marius Gavrilescu
 257
 258 This library is free software; you can redistribute it and/or modify
 259 it under the same terms as Perl itself, either Perl version 5.18.1 or,
 260 at your option, any later version of Perl 5 you may have available.
 261
 262
 263 =cut