use Scalar::Util ();
sub new {
- my ( $class, $hash ) = @_;
+ my ( $class, $config, $app) = @_;
- bless { hash => $hash }, $class;
+ bless { hash => $config->{'users'} }, $class;
}
sub from_session {
return $id if ref $id;
- $self->get_user( $id );
+ $self->find_user( { id => $id } );
}
-sub get_user {
- my ( $self, $id ) = @_;
+## this is not necessarily a good example of what find_user can do, since all we do is
+## look up with the id anyway. find_user can be used to locate a user based on other
+## combinations of data. See C::P::Authentication::Store::DBIx::Class for a better example
+sub find_user {
+ my ( $self, $userinfo, $c ) = @_;
- return unless exists $self->{hash}{$id};
+ my $id = $userinfo->{'id'};
+
+ $id ||= $userinfo->{'username'};
+
+ return unless exists $self->{'hash'}{$id};
- my $user = $self->{hash}{$id};
+ my $user = $self->{'hash'}{$id};
if ( ref $user ) {
if ( Scalar::Util::blessed($user) ) {
- $user->store( $self );
$user->id( $id );
return $user;
}
elsif ( ref $user eq "HASH" ) {
$user->{id} ||= $id;
- $user->{store} ||= $self;
return bless $user, "Catalyst::Plugin::Authentication::User::Hash";
}
else {
$user->supports(@_);
}
+## Backwards compatibility
+#
+# This is a backwards compatible routine. get_user is specifically for loading a user by it's unique id
+# find_user is capable of doing the same by simply passing { id => $id }
+# no new code should be written using get_user as it is deprecated.
+sub get_user {
+ my ( $self, $id ) = @_;
+ $self->find_user({id => $id});
+}
+
+
+
__PACKAGE__;
__END__
use Catalyst qw/
Authentication
- Authentication::Credential::Password
/;
- my %users = (
- user => { password => "s3cr3t" },
- );
+ __PACKAGE__->config->{authentication} =
+ {
+ default_realm => 'members',
+ realms => {
+ members => {
+ credential => {
+ class => 'Password'
+ },
+ store => {
+ class => 'Minimal',
+ users = {
+ bob => {
+ password => "s00p3r",
+ editor => 'yes',
+ roles => [qw/edit delete/],
+ },
+ william => {
+ password => "s3cr3t",
+ roles => [qw/comment/],
+ }
+ }
+ }
+ }
+ }
+ };
+
- our $users = Catalyst::Plugin::Authentication::Store::Minimal::Backend->new(\%users);
+=head1 DESCRIPTION
- sub action : Local {
- my ( $self, $c ) = @_;
+This authentication store backend lets you create a very quick and dirty user
+database in your application's config hash.
- $c->login( $users->get_user( $c->req->param("login") ),
- $c->req->param("password") );
- }
+You will need to include the Authentication plugin, and at least one Credential
+plugin to use this Store. Credential::Password is reccommended.
-=head1 DESCRIPTION
+It's purpose is mainly for testing, and it should probably be replaced by a
+more "serious" store for production.
+
+The hash in the config, as well as the user objects/hashes are freely mutable
+at runtime.
+
+=head1 CONFIGURATION
+
+=over 4
-You probably want L<Catalyst::Plugin::Authentication::Store::Minimal>, unless
-you are mixing several stores in a single app and one of them is Minimal.
+=item class
-Otherwise, this lets you create a store manually.
+The classname used for the store. This is part of
+L<Catalyst::Plugin::Authentication> and is the method by which
+Catalyst::Plugin::Authentication::Store::Minimal::Backend is loaded as the
+user store. For this module to be used, this must be set to
+'Minimal'.
+
+=item users
+
+This is a simple hash of users, the keys are the usenames, and the values are
+hashrefs containing a password key/value pair, and optionally, a roles/list
+of role-names pair. If using roles, you will also need to add the
+Authorization::Roles plugin.
+
+See the SYNOPSIS for an example.
+
+=back
=head1 METHODS
+There are no publicly exported routines in the Minimal store (or indeed in
+most authentication stores) However, below is a description of the routines
+required by L<Catalyst::Plugin::Authentication> for all authentication stores.
+
=over 4
-=item new $hash_ref
+=item new ( $config, $app )
-Constructs a new store object, which uses the supplied hash ref as it's backing
-structure.
+Constructs a new store object, which uses the user element of the supplied config
+hash ref as it's backing structure.
-=item get_user $id
+=item find_user ( $authinfo, $c )
-Keys the hash by $id and returns the value.
+Keys the hash by the 'id' or 'username' element in the authinfo hash and returns the user.
If the return value is unblessed it will be blessed as
L<Catalyst::Plugin::Authentication::User::Hash>.
projects / catagits/Catalyst-Plugin-Authentication.git / blobdiff