view release on metacpan or  search on metacpan

lib/Dancer/Plugin/Auth/Google.pm  view on Meta::CPAN

Anyone with a valid Google account can register an application. Go to
L<http://console.developers.google.com>, then select a project or create
a new one. After that, in the sidebar on the left, select "Credentials".

First, go to the I<OAuth consent screen> tab and set it up with you website's
logo, desired credentials (the "email" and "profile" ones are granted
by default) and, specially, your B<authorized domains>. We'll need those for
the next step!

Now go to the I<Credentials> tab and click the B<Create credentials>
button/dropdown and select B<OAuth client ID>.

=for HTML
<p><img src="https://raw.githubusercontent.com/garu/Dancer-Plugin-Auth-Google/master/share/create-new-id.png"></p>

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/Auth/RBAC/Credentials/Catmandu.pm  view on Meta::CPAN

sub authorize {
    my($self,$options,@arguments) = @_;
    my($login,$password) = @arguments;

    #what are you doing here? You're already in!
    my $user = $self->credentials;
    if(is_hash_ref($user) && ($user->{id} || $user->{login}) && !@{$user->{error}}){

        return $user;

    }

lib/Dancer/Plugin/Auth/RBAC/Credentials/Catmandu.pm  view on Meta::CPAN

        $self->errors('login and password are required');
        return;

    }

    # authorize a new account using supplied credentials
    my $account = $self->bag($options)->get($login);

    if(!is_hash_ref($account)){

        $self->errors('login and/or password is invalid');

lib/Dancer/Plugin/Auth/RBAC/Credentials/Catmandu.pm  view on Meta::CPAN

        login => $account->{login},
        roles => [@{$account->{roles}}],
        error => []
    };

    return $self->credentials($session_data);

}

=head1 NAME

lib/Dancer/Plugin/Auth/RBAC/Credentials/Catmandu.pm  view on Meta::CPAN

=head2 adjust your Dancer config.yml

plugins:
 Auth::RBAC:
  credentials:
   class: Catmandu
   options:
    #name of store in catmandu.yml
    store: 'default'
    #name of table

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/Auth/RBAC/Credentials/DBIC.pm  view on Meta::CPAN

        my $role_name_field = $options->{role_name_field} ||= "name";
        my $user_rs = schema($options->{handle})->resultset($moniker);

        if (my $user = $user_rs->find({ $login_field => $login })) {
            if ($self->_check_password($options, $user, $password)) {
                return $self->credentials({
                    id => $user->$id_field,
                    name => $user->$name_field,
                    login => $user->$login_field,
                    roles => defined($role_relation) ? [ $user->$role_relation->get_column($role_name_field)->all ] : [],
                    error => [],

lib/Dancer/Plugin/Auth/RBAC/Credentials/DBIC.pm  view on Meta::CPAN

        $self->errors('login and/or password is invalid');
        return 0;
    }
    else {
        my $user = $self->{credentials};
        if ($user->{id} || $user->{login} && !@{$user->{error}}) {
            return $user;
        }
        else {
            $self->errors('you are not authorized', 'your session may have ended');

lib/Dancer/Plugin/Auth/RBAC/Credentials/DBIC.pm  view on Meta::CPAN

    plugins:
      DBIC:
        Auth:
          dsn: "dbi:SQLite:dbname=./foo.db"
      Auth::RBAC:
        credentials:
          class: DBIC

The following config options are avaialable:

=over

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/Auth/RBAC/Permissions/DBIC.pm  view on Meta::CPAN

sub subject_asa {
    my ($self, $options, @arguments) = @_;
    my $role = shift @arguments;
    return unless $role;
    my $user = $self->credentials;
    return unless $user->{id};
    my $settings = $class::settings;

    my $moniker = $options->{user_moniker} ||= "User";
    my $role_relation = exists($options->{role_relation}) ? $options->{role_relation} : "roles";

lib/Dancer/Plugin/Auth/RBAC/Permissions/DBIC.pm  view on Meta::CPAN

sub subject_can {
    my ($self, $options, @arguments) = @_;
    my ($operation, $action) = @arguments;
    return unless $operation && $action;
    my $user = $self->credentials;
    return unless $user->{id};
    my $settings = $class::settings;

    my $moniker = $options->{user_moniker} ||= "User";
    my $role_relation = exists($options->{role_relation}) ? $options->{role_relation} : "roles";

lib/Dancer/Plugin/Auth/RBAC/Permissions/DBIC.pm  view on Meta::CPAN

    plugins:
      DBIC:
        Auth:
          dsn: "dbi:SQLite:dbname=./foo.db"
        Auth::RBAC:
          credentials:
            class: DBIC
          permissions:
            class: DBIC

The following config options are avaialable:

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/Auth/RBAC.pm  view on Meta::CPAN

};


sub new {
    my $class = shift;
    my @credentials = @_;
    
    my $credentialsClass =
    __PACKAGE__ . "::Credentials::" . $settings->{credentials}->{class};
    {
        no warnings 'redefine';
        $credentialsClass =~ s/::/\//g;
        require "$credentialsClass.pm";
        $credentialsClass =~ s/\//::/g;
    }
    
    my $self = {};
    bless $self, $class;
    
    # return $credentialsClass->new
    # unless scalar @credentials;
    
    my $user = session('user');
    
    if ($user) {
        # reset authentication errors

lib/Dancer/Plugin/Auth/RBAC.pm  view on Meta::CPAN

        };
    }
    
    session 'user' => $user;
    
    #return $credentialsClass->new->authorize($settings->{credentials}->{options}, @credentials)
    #? $self : undef;
    
    $credentialsClass->new->authorize($settings->{credentials}->{options}, @credentials);
    return $self;
}

sub asa {
    my $self = shift;

lib/Dancer/Plugin/Auth/RBAC.pm  view on Meta::CPAN

=head1 CONFIGURATION

    plugins:
      Auth::RBAC:
        credentials:
          class: Config
          options:
            accounts:
              user01:
                password: foobar

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/Auth/Twitter.pm  view on Meta::CPAN

            token_secret => $token_secret,
            verifier     => $verifier,
        });
        my $twitter_user_hash;
        my $success = eval {
            $twitter_user_hash = twitter->verify_credentials({
                -token        => $access->{oauth_token},
                -token_secret => $access->{oauth_token_secret},
            });
            1;
        };

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/Authorize.pm  view on Meta::CPAN

};


sub new {
    my $class = shift;
    my @credentials = @_;
    
    my $credentialsClass =
    __PACKAGE__ . "::Credentials::" . $settings->{credentials}->{class};
    {
        no warnings 'redefine';
        $credentialsClass =~ s/::/\//g;
        require "$credentialsClass.pm";
        $credentialsClass =~ s/\//::/g;
    }
    
    my $self = {};
    bless $self, $class;
    
    # return $credentialsClass->new
    # unless scalar @credentials;
    
    my $user = session('user');
    
    if ($user) {
        # reset authentication errors

lib/Dancer/Plugin/Authorize.pm  view on Meta::CPAN

        };
    }
    
    session 'user' => $user;
    
    #return $credentialsClass->new->authorize($settings->{credentials}->{options}, @credentials)
    #? $self : undef;
    
    $credentialsClass->new->authorize($settings->{credentials}->{options}, @credentials);
    return $self;
}

sub asa {
    my $self = shift;

lib/Dancer/Plugin/Authorize.pm  view on Meta::CPAN

=head1 CONFIGURATION

    plugins:
      Authorize:
        credentials:
          class: Config
          options:
            accounts:
              user01:
                password: foobar

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/CORS.pm  view on Meta::CPAN

			} else {
				$headers->{'Timing-Allow-Origin'} = 'null';
			}
		}
		
		if (exists $options->{credentials}) {
			if (!!$options->{credentials}) {
				if ($origin eq '*') {
					warning('For a resource that supports credentials a origin matcher must be specified.');
					next RULE;
				}
				$headers->{'Access-Control-Allow-Credentials'} = 'true' ;
			}
		}

lib/Dancer/Plugin/CORS.pm  view on Meta::CPAN

    use Dancer::Plugin::CORS;

    get '/foo' => sub { ... };
	share '/foo' =>
		origin => 'http://localhost/',
		credentials => 1,
		expose => [qw[ Content-Type ]],
		method => 'GET',
		headers => [qw[ X-Requested-With ]],
		maxage => 7200,
		timing => 1,

lib/Dancer/Plugin/CORS.pm  view on Meta::CPAN

		grep { $host eq $_ } qw(localhost 127.0.0.1 ::1)
	}

Hint: a origin consists of protocol, hostname and maybe a port. Examples: C<http://www.example.com>, C<https://securesite.com>, C<http://localhost:3000>, C<http://127.0.0.1>, C<http://[::1]>

=item I<credentials>

This indicates whether cookies, HTTP authentication and/or client-side SSL certificates may sent by a client. Allowed values are C<0> or C<1>.

This option must be used together with I<origin>.

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/FakeCGI/Apache1.pm  view on Meta::CPAN

    #
    # Try to get as much info as possible from CGI.pm, which has
    # workarounds for things like the IIS PATH_INFO bug.
    #
    $self->{headers_in} ||= Apache::Table->new(
        'Authorization' => $self->{query}->auth_type,    # No credentials though.

        #'Cookie' => $ENV{HTTP_COOKIE} || $ENV{COOKIE},
        'Content-Length' => $ENV{CONTENT_LENGTH},
        'Content-Type'   => (
              $self->{query}->can('content_type')

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/LDAP/Handle.pm  view on Meta::CPAN

    return $self->{dancer_settings}->{base};
}

=head2 rebind

Rebind with credentials from settings.

=cut

sub rebind {
    my ($self) = @_;

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/Mango.pm  view on Meta::CPAN

    $dbh->default_db($settings->{db_name})
        if defined $settings->{db_name};

    if (defined $settings->{username} && defined $settings->{password}) {
        push @{$settings->{db_credentials}}, [ $settings->{db_name}, $settings->{username}, $settings->{password}];
    }


    if (defined $settings->{db_credentials} and ref $settings->{db_credentials} eq 'ARRAY') {
        $dbh->credentials($settings->{db_credentials});
    }

    if (defined $settings->{ioloop}) {
        my ( $module, $function ) = split(/\-\>/, $settings->{ioloop});
        $dbh->ioloop($module->$function);

lib/Dancer/Plugin/Mango.pm  view on Meta::CPAN

            db_name: "mydb"
            username: "myuser"
            password: "mypass"
            w: 1
            wtimeout: 1000
            credentials:
                [ mydb, myuser, mypass]
                [ myotherdb, myotheruser, myotherpass]

or:

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/MongoDB.pm  view on Meta::CPAN

    $dbh->default_db($settings->{db_name})
        if defined $settings->{db_name};

    if (defined $settings->{username} && defined $settings->{password}) {
        push @{$settings->{db_credentials}}, [ $settings->{db_name}, $settings->{username}, $settings->{password}];
    }


    if (defined $settings->{db_credentials} and ref $settings->{db_credentials} eq 'ARRAY') {
        $dbh->credentials($settings->{db_credentials});
    }

    if (defined $settings->{ioloop}) {
        my ( $module, $function ) = split(/\-\>/, $settings->{ioloop});
        $dbh->ioloop($module->$function);

lib/Dancer/Plugin/MongoDB.pm  view on Meta::CPAN

            db_name: "mydb"
            username: "myuser"
            password: "mypass"
            w: 1
            wtimeout: 1000
            credentials:
                [ mydb, myuser, mypass]
                [ myotherdb, myotheruser, myotherpass]

or:

 view release on metacpan or  search on metacpan

lib/Dancer/Plugin/SporeDefinitionControl.pm  view on Meta::CPAN

            next if $ko;
            $is_ok = 1;
        }
        return _returned_error($error,400) unless $is_ok;
        
        #set the access-control-allow-credentials if needed
        _set_access_control_header($path_validation->{path}->{$req->{_route_pattern}});
      };
};

lib/Dancer/Plugin/SporeDefinitionControl.pm  view on Meta::CPAN

  #check that header contain origin and that url is permit by api
  $origin_allowed = $req->header('Origin') if ( defined $req->header('Origin') 
                                                  && defined $build_options_route->{'header_allow_allow_origins'} 
                                                  &&  $req->header('Origin') ~~ @{$build_options_route->{'header_allow_allow_origins'}}
                                                );
  header 'access-control-allow-credentials' => $build_options_route->{'header_allow_credentials'} || '';
  header 'access-control-allow-headers' => $build_options_route->{'header_allow_headers'} || '';
  header 'access-control-allow-methods' => join(",",@unique_methods,'OPTIONS');
  header 'access-control-allow-origin' => $origin_allowed if defined $origin_allowed;
  header 'access-control-max-age' => $build_options_route->{'header_max_age'}  || '';
}

 view release on metacpan or  search on metacpan

lib/Dancer2/Plugin/Auth/Extensible/Provider/LDAP.pm  view on Meta::CPAN

    }
    else {
        croak "username and password must be defined"
            unless defined $username && defined $password;

        $self->plugin->app->log( debug => "Binding to LDAP with credentials" );
        $mesg = $ldap->bind( $username, password => $password );
    }

    return $mesg;
}

 view release on metacpan or  search on metacpan

t/01-base.t  view on Meta::CPAN

        ];
    $jar->add_cookie_header($req);
    my $res = $test->request($req);
    $jar->extract_cookies($res);

    ok $res->content =~ m/LOGIN FAILED/, "login with bad credentials get catched"
}
{
    # good login

    $trap->read;

 view release on metacpan or  search on metacpan

lib/Dancer2/Plugin/Auth/HTTP/Basic/DWIW.pm  view on Meta::CPAN

            if(my $handler = $HANDLERS->{check_login}) {
                if(ref($handler) eq 'CODE') {
                    my $check_result = eval { $handler->($username, $password); };

                    if($@) {
                        $dsl->error("Error while validating credentials: $@");
                        die \500;
                    }

                    if(!$check_result) {
                        die \401;

lib/Dancer2/Plugin/Auth/HTTP/Basic/DWIW.pm  view on Meta::CPAN

=head1 DESCRIPTION

This plugin gives you the option to use HTTP Basic authentication with Dancer2.

You can set a handler to check the supplied credentials. If you don't set a handler, every username/password combination will work.

=head1 CAUTION

Don't ever use HTTP Basic authentication over clear-text connections! Always use HTTPS!

 view release on metacpan or  search on metacpan

lib/Dancer2/Plugin/Auth/OAuth/Provider/Twitter.pm  view on Meta::CPAN

    my $request = Net::OAuth->request("protected resource")->new(
        $self->_default_args_v1,
        token           => $session_data->{twitter}{access_token},
        token_secret    => $session_data->{twitter}{access_token_secret},
        request_method  => 'GET',
        request_url     => 'https://api.twitter.com/1.1/account/verify_credentials.json',
    );
    $request->sign;

    my $resp = $self->ua->request(GET $request->to_url);
    if ($resp->is_success) {

 view release on metacpan or  search on metacpan

lib/Dancer2/Plugin/GraphQL.pm  view on Meta::CPAN

      Object.assign(headers, extra_headers);
      return fetch(fetchURL, {
        method: 'post',
        headers: headers,
        body: JSON.stringify(graphQLParams),
        credentials: 'include',
      }).then(function (response) {
        return response.text();
      }).then(function (responseBody) {
        try {
          return JSON.parse(responseBody);

 view release on metacpan or  search on metacpan

lib/Dancer2/Plugin/Growler.pm  view on Meta::CPAN

    use Dancer2::Plugin::Growler;

    …

    my $error = locale->maketext('Invalid login credentials.'); # locale() is from L<Dancer2::Plugin::Locale>
    growl_error($error); 
    redirect '/login';

    …

 view release on metacpan or  search on metacpan

t/30-authenticate_Basic.t  view on Meta::CPAN

    $req->authorization_basic ( 'foo', 'bar');
    my $res = $cb->( $req );
    is (
        $res->code,
        401,
        'Status 401: without proper credentials'
    );
    is (
        $res->headers->header('WWW-Authenticate'),
        qq|Basic realm="some_realm"|,
        'HTTP-field: WWW-Authentication without proper credentials'
    );
    isnt ( # negative testing, we should not get this content
        $res->content,
        qq|Access granted for default realm|,
        'Delivering: without proper credentials'
    );
};

test_psgi $app, sub {
    my $cb = shift;

t/30-authenticate_Basic.t  view on Meta::CPAN

    $req->authorization_basic ( 'dave', 'beer');
    my $res = $cb->( $req );
    is (
        $res->code,
        200,
        'Status 200: with the right credentials'
    );
    isnt ( # negative testing, we should not be required to authenticate
        $res->headers->header('WWW-Authenticate'),
        qq|Basic realm="some_realm"|,
        'HTTP-field: WWW-Authentication with the right credentials'
    );
    is (
        $res->content,
        qq|Access granted for default realm|,
        'Delivering: with the right credentials'
    );
};

#
# Roles

 view release on metacpan or  search on metacpan

lib/Dancer2/Plugin/SPID.pm  view on Meta::CPAN

    dance;

=head1 ABSTRACT

This Perl module is a plugin for the L<Dancer2> web framework. It allows developers of SPID Service Providers to easily add SPID authentication to their Dancer2 applications. L<SPID|https://www.spid.gov.it/> is the Italian digital identity system, wh...

This module provides the highest level of abstraction and ease of use for integration of SPID in a Dancer2 web application. Just set a few configuration options and you'll be able to generate the HTML markup for the SPID button on the fly (to be comp...

See the F<example/> directory for a demo application.

 view release on metacpan or  search on metacpan

Releasing-Dancer2.md  view on Meta::CPAN

The test suite *must* pass before a release can be done. This is your
last chance to resolve any test failures.

Provided the tests pass, you will be prompted to continue the release
process. Provided you have your PAUSE credentials set up, this will
upload the new dist to PAUSE. If you don't have a credential file set
up, you can manually update the new release via the PAUSE web interface.

### Send out release announcements

 view release on metacpan or  search on metacpan

share/assets/dash_core_components/async~plotlyjs.js  view on Meta::CPAN

(window.webpackJsonpdash_core_components=window.webpackJsonpdash_core_components||[]).push([[5],{685:function(t,e){!function(r){"object"==typeof e&&void 0!==t?t.exports=r():"function"==typeof define&&define.amd?define([],r):("undefined"!=typeof windo...

 view release on metacpan or  search on metacpan

examples/babel.pl  view on Meta::CPAN

# open and possibly create AutoDB database
my %db_params=(create=>$OPTIONS{create},database=>$OPTIONS{database},host=>$OPTIONS{host},
	       user=>$OPTIONS{user},password=>$OPTIONS{password});
my $autodb=new Class::AutoDB(%db_params);
unless ($autodb->is_connected) {
  my $errstr='Cannot connect to AutoDB database using supplied credentials: '.
    join(', ',map {"$_=$OPTIONS{$_}"} (qw(database host user password)));
  confess $errstr;
}

# set autodb class attribute in Babel

 view release on metacpan or  search on metacpan

lib/Data/Downloader/Feed.pm  view on Meta::CPAN

    my ($xp,$context,$xpath) = @_;
    my $xpc = XML::LibXML::XPathContext->new($context);
    $xpc->registerNs(default => $defaultNamespaceURI) if $defaultNamespaceURI;
    my $value = $xpc->findvalue($xpath);
    TRACE "got $value from $xpath";
    LOGDIE "Got 'Bad credentials' for feed ".$self->name if $value && $value eq "Bad credentials";
    return $value;
}

sub _make_unique_filename {
    my $self = shift;

lib/Data/Downloader/Feed.pm  view on Meta::CPAN

Refreshing a feed may also :
 - remove files which are now obolete (because the feed has a urn for a different file)
 - update the symlinks for files whose metadata has changed

Also if both "user" and "password" are passed, they are treated specially
and sent as HTTP Basic auth credentials for the rss feed.

=cut

sub refresh {
    my $self = shift;

 view release on metacpan or  search on metacpan

lib/Data/Mirror.pm  view on Meta::CPAN

=head2 $UA

This is an L<LWP::UserAgent> object used to retrieve remote resources. You
may wish to use this variable to configure various aspects of its behaviour,
such as credentials, user agent string, TLS options, etc.

=head2 $JSON

This is a L<JSON::XS> object used for JSON decoding. You may wish to use this
variable to change how it processes JSON data.

 view release on metacpan or  search on metacpan

scripts/passphrase-test  view on Meta::CPAN

use Readonly;
use Test::More;

Readonly my $DEFAULT_RULES_FILE => '/etc/passphrase_rules';

# subclass of LWP::UserAgent that grabs credentials
my $Username = $ENV{LOGNAME};
my $Password;
package MyAgent;
use base qw(LWP::UserAgent);
sub get_basic_credentials { ($Username, $Password) };
package main;

# parse command line
my ($debug, $help, $location);
my $file = $DEFAULT_RULES_FILE;

 view release on metacpan or  search on metacpan

share/dictionary.txt  view on Meta::CPAN

creatures
credence
credence's
credential
credential's
credentials
credenza
credenza's
credenzas
credibility
credibility's

 view release on metacpan or  search on metacpan

lib/Data/Password/zxcvbn/RankedDictionaries/English.pm  view on Meta::CPAN

    'creations' => 3051,
    'creatively' => 17321,
    'creature' => 1948,
    'creatures' => 2868,
    'credence' => 12853,
    'credentials' => 4343,
    'credenza' => 18359,
    'credibility' => 4342,
    'credible' => 7015,
    'credit' => 945,
    'credo' => 13306,