source: trunk/lib/Epoll/DB/Poll/Bdata.pm @ 439

package Epoll::DB::Poll::Bdata;

# $Id$

use strict;
use warnings;
use base 'Epoll::DB::common';
use Epoll::DB::Poll;
use YAML ();
use Crypt::CBC;
use Crypt::DES_EDE3; # Called from CBC

=head1 NAME

Epoll::Model::Vote - Catalyst Model

=head1 DESCRIPTION

Catalyst Model.

=cut

sub new {
    my ($class, $dbstring, $poll) = @_;
    
    bless {
        poll => $poll,
        dbstring => $dbstring,
        db => Epoll::DB::common::_newdb($dbstring),
        data => {},
    }, $class;
}

sub voteid { $_[0]->poll->voteid }

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

sub uid {
    my ($self) = @_;
    $self->{data}{id} ||= Epoll::DB::common::gen_uid();
}

sub xmlout {
    my ($self) = @_;
    $self->uid;
    YAML::Dump($self->{data});
}

sub xmlin {
    my ($self, $data) = @_;
    $self->{data} = YAML::Load($data);
}

sub _store_clear {
    my ($self) = @_;
    my $addb = $self->db->prepare_cached(
        q{
        insert into ballot (id, poll, invalid) values (?,?,?)
        }
    );

    my $needvalid = 'f';
    my %items = ();
    foreach(keys %{$self->{data}{content} || {}}) {
        if ($self->poll->find_choice_key($_)) {
            $items{$_} = 't';
        } else {
            $items{$_} = 'f';
            $needvalid = undef;
        }
    }

    $addb->execute($self->uid, $self->voteid, $needvalid) or do {
        $self->rollback;
        return;
    };

    my $addbc = $self->db->prepare_cached(
        q{
        insert into ballot_item (id, value, fromlist, weight) values (?,?,?,?)
        }
    );
    foreach (keys %{$self->{data}{content} || {}}) {
        $_ or next;
        $addbc->execute($self->uid, $_, $items{$_}, $self->{data}{content}{$_}) or do {
            $self->rollback;
            return;
        };
    }

    1;
}

sub _store_crypted {
    my ($self) = @_;
    
    my $addenc = $self->db->prepare_cached(
        q{insert into ballot_enc (id, data, enckey, poll) values (?,?,?,?)}
    );
    my $uid = Epoll::DB::common::gen_uid();
    
    if (my $pollkey = $self->poll->public_key) {
        my $symkey = map{ chr(rand(256)) } (1 .. 24);
        my $cipher = new Crypt::CBC($symkey, 'DES_EDE3');
        my $encryptedballot = $cipher->encrypt_hex(
            $self->xmlout()
        );
        my $encsymkey = $self->poll->rsa->encrypt (
            Message    => $symkey,
            Key        => $self->poll->public_key,
            Armour     => 1,
        ) || die $self->poll->rsa->errstr();
        $addenc->execute($uid, $encryptedballot, $encsymkey, $self->voteid);
    } else {
        $addenc->execute($uid, $self->xmlout(), undef, $self->voteid);
    }
}

sub _load_crypted {
    my ($self, $ballotid, $privkey) = @_;
    my $sth = $self->db->prepare_cached(
        q{select * from ballot_enc where id = ? for update}
    );
    $sth->execute($ballotid);
    my $ballot = $sth->fetchrow_hashref;
    $sth->finish;
    if ($ballot->{enckey}) {
        $self->_load_crypted_data($ballot->{data}, $ballot->{enckey}, $privkey);
    } else {
        return $ballot->{data}
    }
}

sub _load_crypted_data {
    my ($self, $data, $encsymkey, $privkey) = @_;
    if ($encsymkey) {
        my $symkey = $self->poll->rsa->decrypt (
            Cyphertext => $encsymkey,
            Key        => $privkey,
            Armour     => 1,
        ) || die $self->poll->rsa->errstr();
        my $cipher = new Crypt::CBC($symkey, 'DES_EDE3');
        return $self->xmlin($cipher->decrypt_hex($data));
    } else {
        return $self->xmlin($data);
    }
}

sub decrypt_data {
    my ($self, $ballotid, $data, $encsymkey, $privkey) = @_;
    if ($self->_load_crypted_data($data, $encsymkey, $privkey) &&
        $self->_store_clear &&
        $self->_set_decrypted($ballotid)) {
        $self->commit;
        return;
    } else {
        $self->rollback;
        return 1;
    }
}

sub _set_decrypted {
    my ($self, $ballotid) = @_;
    my $upd = $self->db->prepare_cached(q{update ballot_enc set decrypted = true where id = ?});
    $upd->execute($ballotid)
}

sub decrypt {
    my ($self, $ballotid, $privkey) = @_;
    $self->_load_crypted($ballotid, $privkey);
    $self->_store_clear or return;
    if ($self->_set_decrypted($ballotid)) {
        $self->commit;
        return;
    } else {
        $self->rollback;
        return 1;
    }
}


=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;