File Coverage

blib/lib/Authen/OATH/KeyURI.pm

Criterion	Covered	Total	%
statement	45	46	97.8
branch	15	16	93.7
condition	6	6	100.0
subroutine	11	11	100.0
pod	1	3	33.3
total	78	82	95.1

package Authen::OATH::KeyURI;
use 5.008001;
use strict;
use warnings;

our $VERSION = "0.02";

use base 'Class::Accessor::Fast';
use Params::Validate qw(SCALAR);
use URI;
use Convert::Base32 qw(encode_base32);

__PACKAGE__->mk_accessors(qw(
    scheme
    type
    accountname
    secret
    issuer
    algorithm
    digits
    counter
    period
    uri
    is_encoded
));

sub new {
    my $class = shift;
    my @args = @_ == 1 ? %{$_[0]} : @_;
    my %params = Params::Validate::validate_with(
        params => \@args,
        spec => {
            scheme      => {
                type     => SCALAR,
                default  => q{otpauth},
                optional => 1,
            },
            type        => {
                type     => SCALAR,
                default  => q{totp},
                optional => 1,
            },
            accountname => {
                type     => SCALAR,
            },
            secret      => {
                type     => SCALAR,
            },
            issuer      => {
                type     => SCALAR,
                optional => 1,
            },
            algorithm   => {
                type     => SCALAR,
                optional => 1,
            },
            digits      => {
                type     => SCALAR,
                optional => 1,
            },
            counter     => {
                type     => SCALAR,
                optional => 1,
            },
            period      => {
                type     => SCALAR,
                optional => 1,
            },
            is_encoded  => {
                type     => SCALAR,
                default  => 0,
                optional => 1,
            },
        },
        allow_extra => 0,
    );

    my $self = bless \%params, $class;

    # TODO: more varidation

    return $self;
}

sub as_string {
    my $self = shift;
    $self->_generate_uri();
    return $self->uri->as_string;
}

sub as_uri {
    my $self = shift;
    $self->_generate_uri();
    return $self->uri;
}

sub _generate_uri {
    my $self = shift;

    # 1. Scheme
    my $uri = URI->new;
    $uri->scheme($self->scheme);

    # 2. Type and Label
    my $label =
        ($self->issuer) ?
            $self->issuer . q{:} . $self->accountname :
            $self->accountname;
    $uri->path(q{//} . $self->type . q{/} . $label);

    # 3. Parameters
    my $params = {
        secret => ($self->is_encoded) ? $self->secret : encode_base32($self->secret),
    };
    $params->{issuer}     = $self->issuer    if $self->issuer;
    $params->{algorithm } = $self->algorithm if $self->algorithm ;
    $params->{digits}     = $self->digits    if $self->digits;

    # hotp only
    $params->{counter}    = $self->counter
        if ($self->counter && $self->type eq q{hotp});
    # totp only
    $params->{period}     = $self->period
        if ($self->period && $self->type eq q{totp});

    $uri->query_form($params);

    $self->uri($uri);
}

1;
__END__