view release on metacpan or  search on metacpan

lib/Catalyst/Authentication/Realm.pm  view on Meta::CPAN

    ### BACKWARDS COMPATIBILITY - DEPRECATION WARNING:
    ###  we must eval the ensure_class_loaded - because we might need to try the old-style
    ###  ::Plugin:: module naming if the standard method fails.

    ## Note to self - catch second exception and bitch in detail?

    try {
        Catalyst::Utils::ensure_class_loaded( $credentialclass );
    }
    catch {
        # If the file is missing, then try the old-style fallback,
        # but re-throw anything else for the user to deal with.
        die $_ unless /^Can't locate/;
        $app->log->warn( qq(Credential class "$credentialclass" not found, trying deprecated ::Plugin:: style naming. ) );
        my $origcredentialclass = $credentialclass;
        $credentialclass =~ s/Catalyst::Authentication/Catalyst::Plugin::Authentication/;

        try { Catalyst::Utils::ensure_class_loaded( $credentialclass ); }
        catch {
            # Likewise this croak is useful if the second exception is also "not found",
            # but would be confusing if it's anything else.
            die $_ unless /^Can't locate/;
            Carp::croak "Unable to load credential class, " . $origcredentialclass . " OR " . $credentialclass .
                        " in realm " . $self->name;
        };
    };

    try {
        Catalyst::Utils::ensure_class_loaded( $storeclass );
    }
    catch {
        # If the file is missing, then try the old-style fallback,
        # but re-throw anything else for the user to deal with.
        die $_ unless /^Can't locate/;
        $app->log->warn( qq(Store class "$storeclass" not found, trying deprecated ::Plugin:: style naming. ) );
        my $origstoreclass = $storeclass;
        $storeclass =~ s/Catalyst::Authentication/Catalyst::Plugin::Authentication/;
        try { Catalyst::Utils::ensure_class_loaded( $storeclass ); }
        catch {
            # Likewise this croak is useful if the second exception is also "not found",
            # but would be confusing if it's anything else.
            die $_ unless /^Can't locate/;
            Carp::croak "Unable to load store class, " . $origstoreclass . " OR " . $storeclass .
                        " in realm " . $self->name;
        };
    };

    # BACKWARDS COMPATIBILITY - if the store class does not define find_user, we define it in terms
    # of get_user and add it to the class.  this is because the auth routines use find_user,
    # and rely on it being present. (this avoids per-call checks)
    if (!$storeclass->can('find_user')) {
        no strict 'refs';
        *{"${storeclass}::find_user"} = sub {
                                                my ($self, $info) = @_;
                                                my @rest = @{$info->{rest}} if exists($info->{rest});
                                                $self->get_user($info->{id}, @rest);
                                            };
    }

    ## a little cruft to stay compatible with some poorly written stores / credentials
    ## we'll remove this soon.
    if ($storeclass->can('new')) {
        $self->store($storeclass->new($config->{'store'}, $app, $self));
    }
    else {
        $app->log->error("THIS IS DEPRECATED: $storeclass has no new() method - Attempting to use uninstantiated");
        $self->store($storeclass);
    }
    if ($credentialclass->can('new')) {
        $self->credential($credentialclass->new($config->{'credential'}, $app, $self));
    }
    else {
        $app->log->error("THIS IS DEPRECATED: $credentialclass has no new() method - Attempting to use uninstantiated");
        $self->credential($credentialclass);
    }

    return $self;
}

sub find_user {
    my ( $self, $authinfo, $c ) = @_;

    my $res = $self->store->find_user($authinfo, $c);

    if (!$res) {
      if ($self->config->{'auto_create_user'} && $self->store->can('auto_create_user') ) {
          $res = $self->store->auto_create_user($authinfo, $c);
      }
    } elsif ($self->config->{'auto_update_user'} && $self->store->can('auto_update_user')) {
        $res = $self->store->auto_update_user($authinfo, $c, $res);
    }

    return $res;
}

sub authenticate {
     my ($self, $c, $authinfo) = @_;

     my $user = $self->credential->authenticate($c, $self, $authinfo);
     if (ref($user)) {
         $c->set_authenticated($user, $self->name);
         return $user;
     } else {
         return undef;
     }
}

sub user_is_restorable {
    my ($self, $c) = @_;

    return unless
         $c->can('session')
         and $self->config->{'use_session'}
         and $c->session_is_valid;

    return $c->session->{__user};
}

sub restore_user {
    my ($self, $c, $frozen_user) = @_;