File Coverage

blib/lib/Plack/Middleware/DoormanOpenID.pm

Criterion	Covered	Total	%
statement	18	20	90.0
branch			n/a
condition			n/a
subroutine	7	7	100.0
pod			n/a
total	25	27	92.5

package Plack::Middleware::DoormanOpenID;
use 5.010;
use strict;

our $VERSION   = "0.06";
our $AUTHORITY = "http://gugod.org";

use feature qw(switch);
use parent 'Doorman::PlackMiddleware';

use Plack::Request;
use Plack::Util::Accessor qw(secret ua);

use Net::OpenID::Consumer;
use LWP::UserAgent;
use URI;
use Scalar::Util qw(weaken);

sub prepare_app {
    my $self = shift;

    $self->SUPER::prepare_app(@_);

    $self->secret(
        'This is the default consumer_secret value for Net::OpenID::Consumer
         that you should provide for your own app. ' . $VERSION
    ) unless $self->secret;
    $self->ua('LWP::UserAgent') unless $self->ua;
}

sub openid_verified_url {
    $_[0]->scope_url . "/openid_verified";
}

sub openid_verified_path {
    URI->new($_[0]->openid_verified_url)->path;
}

sub verified_identity_url {
    $_[0]->session_get("verified_identity_url");
}

sub is_sign_in {
    defined $_[0]->verified_identity_url;
}

sub csr {
    my ($self, $request) = @_;
    return Net::OpenID::Consumer->new(
        ua => ref($self->ua) ? $self->ua : $self->ua->new,
        args => sub { $request->param($_[0]) },
        consumer_secret => $self->secret,
        required_root   => $self->root_url
    );
}

sub call {
    my ($self, $env) = @_;
    $self->prepare_call($env);

    $env->{"doorman.@{[ $self->scope ]}.openid"} = $self;

    my $request = Plack::Request->new($env);
    given([$request->method, $request->path]) {
        when(['POST', $self->sign_in_path]) {
            my $csr = $self->csr($request);
            if ($request->param("openid")) {
                if (my $claimed_identity = $csr->claimed_identity( $request->param("openid") )) {
                    my $check_url = $claimed_identity->check_url(
                        delayed_return => 1,
                        return_to      => $self->openid_verified_url,
                        trust_root     => $self->root_url
                    );

                    return [302, ["Location" => $check_url], [""]];
                }
                else {
                    $env->{'doorman.'. $self->scope .'.openid.status'} = 'error';
                    $env->{'doorman.'. $self->scope .'.openid.error'} = $csr->errcode;
                }
            }
        }

        when(['GET', $self->openid_verified_path]) {
            my $csr = $self->csr($request);

            $csr->handle_server_response(
                verified => sub {
                    my $id = shift;

                    $env->{'doorman.'. $self->scope .'.openid.verified_identity'} = $id;
                    $env->{'doorman.'. $self->scope .'.openid.status'} = 'verified';

                    $self->session_set("verified_identity_url", $id->url);
                },
                setup_required => sub {
                    $self->env_set("status", "setup_required");
                },
                cancelled      => sub {
                    $self->env_set("status", "cancelled");
                },
                not_openid     => sub {
                    $self->env_set("status", "not_openid");
                },
                error          => sub {
                    my $err = shift;
                    $self->env_set("status", "error");
                    $self->env_set("error",  $err);
                }
            );
        }

        when(['GET', $self->sign_out_path]) {
            $self->session_remove("verified_identity_url");
        }
    }

    return $self->app->($env);
}

1;

__END__