source: trunk/lib/Vote/DB/Poll/Results.pm @ 217

package Vote::DB::Poll::Results;

# $Id$

use strict;
use warnings;
use base 'Vote::DB::Poll';

=head1 NAME

Vote::Model::Vote - Catalyst Model

=head1 DESCRIPTION

Catalyst Model.

=cut

sub new {
    my ($class, %args) = @_;

    my $res = $class->SUPER::new(%args);
    
    return bless $res, $class;
}

sub absolute_majority {
    my ($self) = @_;
    my $ballot_count = $self->voices_ballot_count;
    return int($ballot_count / 2) + 1;
}    

sub abstention {
    my ($self) = @_;
    
    my $sth = $self->db->prepare_cached(
        q{
        select count(*) from ballot where poll = ?
        and id not in (select id from ballot_item) and
        (invalid = 'false' or invalid is null)
        }
    );

    $sth->execute($self->voteid);
    my $res = $sth->fetchrow_hashref;
    $sth->finish;
    $res->{count}
}

sub ballot_count_nonull {not_empty_ballot_count(@_)}

sub voices_ballot_count {
    my ($self) = @_;
    return $self->not_empty_ballot_count +
        ($self->info('empty_ballot_has_voice')
            ? $self->empty_ballot_count
            : 0);
}


sub empty_ballot_count {
    my ($self) = @_;

    my $sth = $self->db->prepare_cached(
        q{
        select count(*) from ballot where poll = ?
        and id not in (select id from ballot_item) and
        (invalid = 'false' or invalid is null)
        }
    );

    $sth->execute($self->voteid);
    my $res = $sth->fetchrow_hashref;
    $sth->finish;
    $res->{count}
}

sub not_empty_ballot_count {
    my ($self) = @_;

    my $sth = $self->db->prepare_cached(
        q{
        select count(*) from ballot where poll = ?
        and id in (select id from ballot_item) and
        (invalid = 'false' or invalid is null)
        }
    );

    $sth->execute($self->voteid);
    my $res = $sth->fetchrow_hashref;
    $sth->finish;
    $res->{count}
}

sub results_count {
    my ($self) = @_;
    $self->_results();
}

sub results_nonull {
    my ($self) = @_;
    $self->_results(1);
}

sub results {
    my ($self) = @_;
    $self->_results(
        $self->info('empty_ballot_has_voice')
        ? 0
        : 1
    );
}

sub _results {
    my ($self, $nonull) = @_;

    my $sth = $self->db->prepare(
        q{
        select count(ballot.id), value from
        (
        select NULL as id, label as value from choice where poll = ?
        union
        select ballot.id, coalesce(corrected, ballot_map.to, value) as "value" from ballot
        } . ($nonull ? '' : ' left ') . q{ join ballot_item
        on ballot.id = ballot_item.id 
        left join ballot_map on ballot.poll = ballot_map.poll and ballot_map.from = ballot_item.value
        where ballot.poll = ? and (invalid = 'false' or invalid is null
        )
        group by ballot.id, coalesce(corrected, ballot_map.to, value)) as ballot
        group by value
        order by count desc, value
        }
    );
    $sth->execute($self->voteid, $self->voteid);
    my @results;
    my $abs_maj = $self->absolute_majority;
    my $wanted_count = $self->info('elected_count');
    my $voice_count = $self->voices_ballot_count;
    while (my $res = $sth->fetchrow_hashref) {
        if ($res->{count} >= $abs_maj) {
            $res->{abs_maj} = 1;
        }
        if (scalar(@results) < $wanted_count) {
            $res->{elected} = 1 if ($res->{count});
        } elsif (scalar(@results)) {
            $res->{elected} = $results[-1]->{elected}
                if($res->{count} == $results[-1]->{count});
        }
        if (scalar(@results)) {
            $res->{order} = ($res->{count} == $results[-1]->{count}
                ? $results[-1]->{order}
                : scalar(@results) + 1);
        } else { $res->{order} = 1 }
        $res->{voices_percent} = $res->{count} / $voice_count * 100
            if($voice_count); # avoid divide by 0

        push(@results, $res);
    }
    \@results;
}

=head1 AUTHOR

Thauvin Olivier

=head1 LICENSE

This library is free software, you can redistribute it and/or modify
it under the same terms as Perl itself or CeCILL.

=cut

1;