File Coverage

blib/lib/Template/Provider/DBI.pm

Criterion	Covered	Total	%
statement	52	68	76.4
branch	13	34	38.2
condition	10	34	29.4
subroutine	7	8	87.5
pod	1	2	50.0
total	83	146	56.8

package Template::Provider::DBI;

use DBI;
use DateTime::Format::DBI;
use base 'Template::Provider';

our $VERSION = '0.03';

sub _init
{
    # check dbi specific params from args, then call super
    # modified timestamps?
    # precompiled?
    my ($self, $args) = @_;

    $self->{$_} = $args->{$_} for keys %$args;

    if($self->{DBI_DBH} && $self->{DBI_DSN})
    {
        return $self->error("DBI:Can't use DBI_DBH and DBI_DSN at the same time");
    }

    if($self->{DBI_DSN})
    {
        $self->{DBI_DBH} = DBI->connect($self->{DBI_DSN}, $self->{DBI_USER}, $self->{DBI_PASSWD}) or return $self->error("DBI: Failed to connect to $self->{DBI_DSN}, $self->{DBI_USER}, $self->{DBI_PASSWD}, $DBI::errstr");
    }

    $self->{DBI_TABLE}         ||= 'templates';
    $self->{DBI_MODIFIEDFIELD} ||= 'modified';
    $self->{DBI_TMPLFIELD}     ||= 'template';
    $self->{DBI_FILEFIELD}     ||= 'filename';
    $self->{DBI_CURRENTTIME}   ||= 'current_timestamp';
#    $self->{DBI_QUERY}         ||= "SELECT $self->{DBI_TMPLFIELD} FROM $self->{DBI_TABLE} WHERE $self->{DBI_FILEFIELD} = ?";

    eval {
        $self->{DBI_DT}        ||= DateTime::Format::DBI->new($self->{DBI_DBH}); };
    if($@)
    {
       warn "DateTime::Format:: for $self->{DBI_DBH}->{Driver}->{Name} not found, no caching supported";
       $self->{DBI_DT} = undef;
       $self->{DBI_MODIFIEDFIELD} = '';
    }

    my $modified = '';
    $modified = ", $self->{DBI_MODIFIEDFIELD}" if($self->{DBI_MODIFIEDFIELD});
    $self->{DBI_QUERY}         ||= "SELECT $self->{DBI_TMPLFIELD} $modified FROM $self->{DBI_TABLE} WHERE $self->{DBI_FILEFIELD} = ?";
    $self->{DBI_STH} = $self->{DBI_DBH}->prepare_cached($self->{DBI_QUERY}) or
        return $self->error("DBI:Failed to prepare query: $DBI:errstr");
    return $self->SUPER::_init();
}

sub fetch
{
    # called to fetch template by name
    # return (undef. status_declined) on missing (and on error & tolerant)
    # return ($error, status_error) on error

    my ($self, $name) = @_;
    my ($data, $error);
    # we dont do refs or handles:
    return (undef, Template::Constants::STATUS_DECLINED) if(ref($name));

    # Check if caching is allowed / file has been cached
#    my $compiled = $self->_compiled_filename($name);
    if(defined $self->{ SIZE } && $self->{ LOOKUP }->{ $name })
    {
        ($data, $error) = _fetch($name);
    }
    else
    {
        ($data, $error) = $self->_load($name);
        ($data, $error) = $self->_compile($data) unless($error);
        $data = $self->_store($name, $data) unless($error);
    }

    return ($data, $error);

}

sub _load
{
    my ($self, $name) = @_;

    my $data = {};
    # fetch template from db
    $self->{DBI_STH}->execute($name);
    my ($templ, $modified) = $self->{DBI_STH}->fetchrow_array();
    return (undef, Template::Constants::STATUS_DECLINED)
        if(!defined $templ);
    if($modified && exists $self->{DBI_DT})
    {
        # No "modified" field used, as we have no DT::Format::X
        $data->{time} = $self->convert_timestamp($modified);
    }
    else
    {
        $data->{time} = time();
    }
    $data->{load} = time();
    $data->{name} = $name;
    $data->{text} = $templ;

    my $err = $DBI::errstr if(!$templ);

    return ($data, $err);
}

## _store uses stat on the filename, bah
## patch to call _mtime($name) ?

sub _modified
{
    my ($self, $name) = @_;

    if(!defined $self->{DBI_DT})
    {
        return time();
    }

    my $sth = $self->{DBI_DBH}->prepare_cached(<
SELECT $self->{DBI_MODIFIEDFIELD}
FROM $self->{DBI_TABLE}
WHERE $self->{DBI_FILEFIELD} = ?
SQL

    $sth->execute($name);
    my ($result) = $sth->fetchrow_array();

    return $self->convert_timestamp($result) || $result;

}

sub convert_timestamp
{
    my ($self, $timestamp) = @_;

    return time() if(!$timestamp);
    if($self->{DBI_DT} && $self->{DBI_DT}->can('parse_timestamp'))
    {
        my $dt = $self->{DBI_DT}->parse_timestamp($timestamp);
        return $dt->epoch;
    }
    elsif($self->{DBI_DT} && $self->{DBI_DT}->can('format_datetime'))
    {
        my $dt = $self->{DBI_DT}->parse_datetime($timestamp);
        return $dt->epoch;
    }
    return 0;
}


1;

__END__