X-Git-Url: http://wagnertech.de/git?a=blobdiff_plain;f=SL%2FAuth.pm;h=52c2dc63de55510ce115ade02d53387d32f82368;hb=00e9a5851ed2d58e0f417d5f5d103f4f48338321;hp=8b8d859ae2c7ad060c0a23638c357e1a63f659f1;hpb=27ae86579fb8833067e9d6c02cf5429d98b28449;p=kivitendo-erp.git diff --git a/SL/Auth.pm b/SL/Auth.pm index 8b8d859ae..52c2dc63d 100644 --- a/SL/Auth.pm +++ b/SL/Auth.pm @@ -8,10 +8,14 @@ use Time::HiRes qw(gettimeofday); use List::MoreUtils qw(uniq); use YAML; +use SL::Auth::ColumnInformation; use SL::Auth::Constants qw(:all); use SL::Auth::DB; use SL::Auth::LDAP; +use SL::Auth::Password; +use SL::Auth::SessionValue; +use SL::SessionFile; use SL::User; use SL::DBConnect; use SL::DBUpgrade2; @@ -19,6 +23,9 @@ use SL::DBUtils; use strict; +use constant SESSION_KEY_ROOT_AUTH => 'session_auth_status_root'; +use constant SESSION_KEY_USER_AUTH => 'session_auth_status_user'; + sub new { $main::lxdebug->enter_sub(); @@ -27,9 +34,8 @@ sub new { bless $self, $type; - $self->{SESSION} = { }; - $self->_read_auth_config(); + $self->reset; $main::lxdebug->leave_sub(); @@ -39,15 +45,19 @@ sub new { sub reset { my ($self, %params) = @_; - $self->{SESSION} = { }; - $self->{FULL_RIGHTS} = { }; - $self->{RIGHTS} = { }; - $self->{unique_counter} = 0; + $self->{SESSION} = { }; + $self->{FULL_RIGHTS} = { }; + $self->{RIGHTS} = { }; + $self->{unique_counter} = 0; + $self->{column_information} = SL::Auth::ColumnInformation->new(auth => $self); + $self->{authenticator}->reset; } sub get_user_dbh { - my ($self, $login) = @_; - my %user = $self->read_user($login); + my ($self, $login, %params) = @_; + my $may_fail = delete $params{may_fail}; + + my %user = $self->read_user(login => $login); my $dbh = SL::DBConnect->connect( $user{dbconnect}, $user{dbuser}, @@ -56,9 +66,13 @@ sub get_user_dbh { pg_enable_utf8 => $::locale->is_utf8, AutoCommit => 0 } - ) or $::form->dberror; + ); - if ($user{dboptions}) { + if (!$may_fail && !$dbh) { + $::form->error($::locale->text('The connection to the authentication database failed:') . "\n" . $DBI::errstr); + } + + if ($user{dboptions} && $dbh) { $dbh->do($user{dboptions}) or $::form->dberror($user{dboptions}); } @@ -91,6 +105,10 @@ sub _read_auth_config { my $self = shift; map { $self->{$_} = $::lx_office_conf{authentication}->{$_} } keys %{ $::lx_office_conf{authentication} }; + + # Prevent password leakage to log files when dumping Auth instances. + $self->{admin_password} = sub { $::lx_office_conf{authentication}->{admin_password} }; + $self->{DB_config} = $::lx_office_conf{'authentication/database'}; $self->{LDAP_config} = $::lx_office_conf{'authentication/ldap'}; @@ -129,18 +147,27 @@ sub _read_auth_config { sub authenticate_root { $main::lxdebug->enter_sub(); - my $self = shift; - my $password = shift; - my $is_crypted = shift; + my ($self, $password) = @_; - $password = crypt $password, 'ro' if (!$password || !$is_crypted); - my $admin_password = crypt "$self->{admin_password}", 'ro'; + my $session_root_auth = $self->get_session_value(SESSION_KEY_ROOT_AUTH()); + if (defined $session_root_auth && $session_root_auth == OK) { + $::lxdebug->leave_sub; + return OK; + } - $main::lxdebug->leave_sub(); + if (!defined $password) { + $::lxdebug->leave_sub; + return ERR_PASSWORD; + } + + $password = SL::Auth::Password->hash(login => 'root', password => $password); + my $admin_password = SL::Auth::Password->hash_if_unhashed(login => 'root', password => $self->{admin_password}->()); + + my $result = $password eq $admin_password ? OK : ERR_PASSWORD; + $self->set_session_value(SESSION_KEY_ROOT_AUTH() => $result); - return OK if $password eq $admin_password; - sleep 5; - return ERR_PASSWORD; + $::lxdebug->leave_sub; + return $result; } sub authenticate { @@ -148,14 +175,42 @@ sub authenticate { my ($self, $login, $password) = @_; - $main::lxdebug->leave_sub(); + my $session_auth = $self->get_session_value(SESSION_KEY_USER_AUTH()); + if (defined $session_auth && $session_auth == OK) { + $::lxdebug->leave_sub; + return OK; + } + + if (!defined $password) { + $::lxdebug->leave_sub; + return ERR_PASSWORD; + } my $result = $login ? $self->{authenticator}->authenticate($login, $password) : ERR_USER; - return OK if $result eq OK; - sleep 5; + $self->set_session_value(SESSION_KEY_USER_AUTH() => $result, login => $login); + + $::lxdebug->leave_sub; return $result; } +sub punish_wrong_login { + my $failed_login_penalty = ($::lx_office_conf{authentication} || {})->{failed_login_penalty}; + sleep $failed_login_penalty if $failed_login_penalty; +} + +sub get_stored_password { + my ($self, $login) = @_; + + my $dbh = $self->dbconnect; + + return undef unless $dbh; + + my $query = qq|SELECT password FROM auth."user" WHERE login = ?|; + my ($stored_password) = $dbh->selectrow_array($query, undef, $login); + + return $stored_password; +} + sub dbconnect { $main::lxdebug->enter_sub(2); @@ -203,9 +258,9 @@ sub dbdisconnect { sub check_tables { $main::lxdebug->enter_sub(); - my $self = shift; + my ($self, $dbh) = @_; - my $dbh = $self->dbconnect(); + $dbh ||= $self->dbconnect(); my $query = qq|SELECT COUNT(*) FROM pg_tables WHERE (schemaname = 'auth') AND (tablename = 'user')|; my ($count) = $dbh->selectrow_array($query); @@ -355,8 +410,9 @@ sub can_change_password { sub change_password { $main::lxdebug->enter_sub(); - my $self = shift; - my $result = $self->{authenticator}->change_password(@_); + my ($self, $login, $new_password) = @_; + + my $result = $self->{authenticator}->change_password($login, $new_password); $main::lxdebug->leave_sub(); @@ -369,15 +425,30 @@ sub read_all_users { my $self = shift; my $dbh = $self->dbconnect(); - my $query = qq|SELECT u.id, u.login, cfg.cfg_key, cfg.cfg_value - FROM auth.user_config cfg - LEFT JOIN auth."user" u ON (cfg.user_id = u.id)|; + my $query = qq|SELECT u.id, u.login, cfg.cfg_key, cfg.cfg_value, s.mtime AS last_action + + FROM auth."user" AS u + + LEFT JOIN auth.user_config AS cfg + ON (cfg.user_id = u.id) + + LEFT JOIN auth.session_content AS sc_login + ON (sc_login.sess_key = 'login' AND sc_login.sess_value = ('--- ' \|\| u.login \|\| '\n')) + + LEFT JOIN auth.session AS s + ON (s.id = sc_login.session_id) + |; my $sth = prepare_execute_query($main::form, $dbh, $query); my %users; while (my $ref = $sth->fetchrow_hashref()) { - $users{$ref->{login}} ||= { 'login' => $ref->{login}, 'id' => $ref->{id} }; + + $users{$ref->{login}} ||= { + 'login' => $ref->{login}, + 'id' => $ref->{id}, + 'last_action' => $ref->{last_action}, + }; $users{$ref->{login}}->{$ref->{cfg_key}} = $ref->{cfg_value} if (($ref->{cfg_key} ne 'login') && ($ref->{cfg_key} ne 'id')); } @@ -391,15 +462,25 @@ sub read_all_users { sub read_user { $main::lxdebug->enter_sub(); - my $self = shift; - my $login = shift; + my ($self, %params) = @_; my $dbh = $self->dbconnect(); + + my (@where, @values); + if ($params{login}) { + push @where, 'u.login = ?'; + push @values, $params{login}; + } + if ($params{id}) { + push @where, 'u.id = ?'; + push @values, $params{id}; + } + my $where = join ' AND ', '1 = 1', @where; my $query = qq|SELECT u.id, u.login, cfg.cfg_key, cfg.cfg_value FROM auth.user_config cfg LEFT JOIN auth."user" u ON (cfg.user_id = u.id) - WHERE (u.login = ?)|; - my $sth = prepare_execute_query($main::form, $dbh, $query, $login); + WHERE $where|; + my $sth = prepare_execute_query($main::form, $dbh, $query, @values); my %user_data; @@ -408,6 +489,9 @@ sub read_user { @user_data{qw(id login)} = @{$ref}{qw(id login)}; } + # The XUL/XML backed menu has been removed. + $user_data{menustyle} = 'v3' if lc($user_data{menustyle} || '') eq 'xml'; + $sth->finish(); $main::lxdebug->leave_sub(); @@ -430,29 +514,33 @@ sub get_user_id { } sub delete_user { - $main::lxdebug->enter_sub(); + $::lxdebug->enter_sub; my $self = shift; my $login = shift; - my $form = $main::form; - - my $dbh = $self->dbconnect(); + my $dbh = $self->dbconnect; + my $id = $self->get_user_id($login); + my $user_db_exists; - $dbh->begin_work; + $dbh->rollback and return $::lxdebug->leave_sub if (!$id); - my $query = qq|SELECT id FROM auth."user" WHERE login = ?|; + my $u_dbh = $self->get_user_dbh($login, may_fail => 1); + $user_db_exists = $self->check_tables($u_dbh) if $u_dbh; - my ($id) = selectrow_query($form, $dbh, $query, $login); + $u_dbh->begin_work if $u_dbh && $user_db_exists; - $dbh->rollback and return $main::lxdebug->leave_sub() if (!$id); + $dbh->begin_work; - do_query($form, $dbh, qq|DELETE FROM auth.user_group WHERE user_id = ?|, $id); - do_query($form, $dbh, qq|DELETE FROM auth.user_config WHERE user_id = ?|, $id); + do_query($::form, $dbh, qq|DELETE FROM auth.user_group WHERE user_id = ?|, $id); + do_query($::form, $dbh, qq|DELETE FROM auth.user_config WHERE user_id = ?|, $id); + do_query($::form, $dbh, qq|DELETE FROM auth.user WHERE id = ?|, $id); + do_query($::form, $u_dbh, qq|UPDATE employee SET deleted = 't' WHERE login = ?|, $login) if $u_dbh && $user_db_exists; - $dbh->commit(); + $dbh->commit; + $u_dbh->commit if $u_dbh && $user_db_exists; - $main::lxdebug->leave_sub(); + $::lxdebug->leave_sub; } # -------------------------------------- @@ -464,11 +552,8 @@ sub restore_session { my $self = shift; - my $cgi = $main::cgi; - $cgi ||= CGI->new(''); - - $session_id = $cgi->cookie($self->get_session_cookie_name()); - $session_id =~ s|[^0-9a-f]||g; + $session_id = $::request->{cgi}->cookie($self->get_session_cookie_name()); + $session_id =~ s|[^0-9a-f]||g if $session_id; $self->{SESSION} = { }; @@ -481,10 +566,24 @@ sub restore_session { $form = $main::form; - $dbh = $self->dbconnect(); + # Don't fail if the auth DB doesn't yet. + if (!( $dbh = $self->dbconnect(1) )) { + $::lxdebug->leave_sub; + return SESSION_NONE; + } + + # Don't fail if the "auth" schema doesn't exist yet, e.g. if the + # admin is creating the session tables at the moment. $query = qq|SELECT *, (mtime < (now() - '$self->{session_timeout}m'::interval)) AS is_expired FROM auth.session WHERE id = ?|; - $cookie = selectfirst_hashref_query($form, $dbh, $query, $session_id); + if (!($sth = $dbh->prepare($query)) || !$sth->execute($session_id)) { + $sth->finish if $sth; + $::lxdebug->leave_sub; + return SESSION_NONE; + } + + $cookie = $sth->fetchrow_hashref; + $sth->finish; if (!$cookie || $cookie->{is_expired} || ($cookie->{ip_address} ne $ENV{REMOTE_ADDR})) { $self->destroy_session(); @@ -492,45 +591,85 @@ sub restore_session { return $cookie ? SESSION_EXPIRED : SESSION_NONE; } - $query = qq|SELECT sess_key, sess_value FROM auth.session_content WHERE session_id = ?|; - $sth = prepare_execute_query($form, $dbh, $query, $session_id); - - while (my $ref = $sth->fetchrow_hashref()) { - $self->{SESSION}->{$ref->{sess_key}} = $ref->{sess_value}; - next if defined $form->{$ref->{sess_key}}; - - my $params = $self->_load_value($ref->{sess_value}); - $form->{$ref->{sess_key}} = $params->{data} if $params->{auto_restore} || $params->{simple}; + if ($self->{column_information}->has('auto_restore')) { + $self->_load_with_auto_restore_column($dbh, $session_id); + } else { + $self->_load_without_auto_restore_column($dbh, $session_id); } - $sth->finish(); - $main::lxdebug->leave_sub(); return SESSION_OK; } -sub _load_value { - my ($self, $value) = @_; +sub _load_without_auto_restore_column { + my ($self, $dbh, $session_id) = @_; - return { simple => 1, data => $value } if $value !~ m/^---/; + my $query = < 1 ); - eval { - my $data = YAML::Load($value); + while (my $ref = $sth->fetchrow_hashref) { + my $value = SL::Auth::SessionValue->new(auth => $self, + key => $ref->{sess_key}, + value => $ref->{sess_value}, + raw => 1); + $self->{SESSION}->{ $ref->{sess_key} } = $value; - if (ref $data eq 'HASH') { - map { $params{$_} = $data->{$_} } keys %{ $data }; - $params{simple} = 0; + next if defined $::form->{$ref->{sess_key}}; - } else { - $params{data} = $data; - } + my $data = $value->get; + $::form->{$ref->{sess_key}} = $data if $value->{auto_restore} || !ref $data; + } +} + +sub _load_with_auto_restore_column { + my ($self, $dbh, $session_id) = @_; + + my $auto_restore_keys = join ', ', map { "'${_}'" } qw(login password rpw); - 1; - } or $params{data} = $value; + my $query = <fetchrow_hashref) { + my $value = SL::Auth::SessionValue->new(auth => $self, + key => $ref->{sess_key}, + value => $ref->{sess_value}, + auto_restore => $ref->{auto_restore}, + raw => 1); + $self->{SESSION}->{ $ref->{sess_key} } = $value; + + next if defined $::form->{$ref->{sess_key}}; + + my $data = $value->get; + $::form->{$ref->{sess_key}} = $data if $value->{auto_restore} || !ref $data; + } + + $sth->finish; + + $query = <fetchrow_hashref) { + my $value = SL::Auth::SessionValue->new(auth => $self, + key => $ref->{sess_key}); + $self->{SESSION}->{ $ref->{sess_key} } = $value; + } } sub destroy_session { @@ -548,6 +687,8 @@ sub destroy_session { $dbh->commit(); + SL::SessionFile->destroy_session($session_id); + $session_id = undef; $self->{SESSION} = { }; } @@ -560,26 +701,31 @@ sub expire_sessions { my $self = shift; + $main::lxdebug->leave_sub and return if !$self->session_tables_present; + my $dbh = $self->dbconnect(); - $dbh->begin_work; + my $query = qq|SELECT id + FROM auth.session + WHERE (mtime < (now() - '$self->{session_timeout}m'::interval))|; - my $query = - qq|DELETE FROM auth.session_content - WHERE session_id IN - (SELECT id - FROM auth.session - WHERE (mtime < (now() - '$self->{session_timeout}m'::interval)))|; + my @ids = selectall_array_query($::form, $dbh, $query); - do_query($main::form, $dbh, $query); + if (@ids) { + $dbh->begin_work; - $query = - qq|DELETE FROM auth.session - WHERE (mtime < (now() - '$self->{session_timeout}m'::interval))|; + SL::SessionFile->destroy_session($_) for @ids; - do_query($main::form, $dbh, $query); + $query = qq|DELETE FROM auth.session_content + WHERE session_id IN (| . join(', ', ('?') x scalar(@ids)) . qq|)|; + do_query($main::form, $dbh, $query, @ids); - $dbh->commit(); + $query = qq|DELETE FROM auth.session + WHERE id IN (| . join(', ', ('?') x scalar(@ids)) . qq|)|; + do_query($main::form, $dbh, $query, @ids); + + $dbh->commit(); + } $main::lxdebug->leave_sub(); } @@ -608,16 +754,29 @@ sub save_session { my $dbh = $provided_dbh || $self->dbconnect(1); - $::lxdebug->leave_sub && return unless $dbh; + $::lxdebug->leave_sub && return unless $dbh && $session_id; $dbh->begin_work unless $provided_dbh; - do_query($::form, $dbh, qq|LOCK auth.session_content|); - do_query($::form, $dbh, qq|DELETE FROM auth.session_content WHERE session_id = ?|, $session_id); + # If this fails then the "auth" schema might not exist yet, e.g. if + # the admin is just trying to create the auth database. + if (!$dbh->do(qq|LOCK auth.session_content|)) { + $dbh->rollback unless $provided_dbh; + $::lxdebug->leave_sub; + return; + } + + my @unfetched_keys = map { $_->{key} } + grep { ! $_->{fetched} } + values %{ $self->{SESSION} }; + # $::lxdebug->dump(0, "unfetched_keys", [ sort @unfetched_keys ]); + # $::lxdebug->dump(0, "all keys", [ sort map { $_->{key} } values %{ $self->{SESSION} } ]); + my $query = qq|DELETE FROM auth.session_content WHERE (session_id = ?)|; + $query .= qq| AND (sess_key NOT IN (| . join(', ', ('?') x scalar @unfetched_keys) . qq|))| if @unfetched_keys; - my $query = qq|SELECT id FROM auth.session WHERE id = ?|; + do_query($::form, $dbh, $query, $session_id, @unfetched_keys); - my ($id) = selectrow_query($::form, $dbh, $query, $session_id); + my ($id) = selectrow_query($::form, $dbh, qq|SELECT id FROM auth.session WHERE id = ?|, $session_id); if ($id) { do_query($::form, $dbh, qq|UPDATE auth.session SET mtime = now() WHERE id = ?|, $session_id); @@ -625,12 +784,25 @@ sub save_session { do_query($::form, $dbh, qq|INSERT INTO auth.session (id, ip_address, mtime) VALUES (?, ?, now())|, $session_id, $ENV{REMOTE_ADDR}); } - if (%{ $self->{SESSION} }) { - my $query = qq|INSERT INTO auth.session_content (session_id, sess_key, sess_value) VALUES (?, ?, ?)|; - my $sth = prepare_query($::form, $dbh, $query); + my @values_to_save = grep { $_->{fetched} } + values %{ $self->{SESSION} }; + if (@values_to_save) { + my ($columns, $placeholders) = ('', ''); + my $auto_restore = $self->{column_information}->has('auto_restore'); - foreach my $key (sort keys %{ $self->{SESSION} }) { - do_statement($::form, $sth, $query, $session_id, $key, $self->{SESSION}->{$key}); + if ($auto_restore) { + $columns .= ', auto_restore'; + $placeholders .= ', ?'; + } + + $query = qq|INSERT INTO auth.session_content (session_id, sess_key, sess_value ${columns}) VALUES (?, ?, ? ${placeholders})|; + my $sth = prepare_query($::form, $dbh, $query); + + foreach my $value (@values_to_save) { + my @values = ($value->{key}, $value->get_dumped); + push @values, $value->{auto_restore} if $auto_restore; + + do_statement($::form, $sth, $query, $session_id, @values); } $sth->finish(); @@ -644,12 +816,23 @@ sub set_session_value { $main::lxdebug->enter_sub(); my $self = shift; - my %params = @_; + my @params = @_; $self->{SESSION} ||= { }; - while (my ($key, $value) = each %params) { - $self->{SESSION}->{ $key } = YAML::Dump(ref($value) eq 'HASH' ? { data => $value } : $value); + while (@params) { + my $key = shift @params; + + if (ref $key eq 'HASH') { + $self->{SESSION}->{ $key->{key} } = SL::Auth::SessionValue->new(key => $key->{key}, + value => $key->{value}, + auto_restore => $key->{auto_restore}); + + } else { + my $value = shift @params; + $self->{SESSION}->{ $key } = SL::Auth::SessionValue->new(key => $key, + value => $value); + } } $main::lxdebug->leave_sub(); @@ -673,12 +856,12 @@ sub delete_session_value { sub get_session_value { $main::lxdebug->enter_sub(); - my $self = shift; - my $params = $self->{SESSION} ? $self->_load_value($self->{SESSION}->{ $_[0] }) : {}; + my $self = shift; + my $data = $self->{SESSION} && $self->{SESSION}->{ $_[0] } ? $self->{SESSION}->{ $_[0] }->get : undef; $main::lxdebug->leave_sub(); - return $params->{data}; + return $data; } sub create_unique_sesion_value { @@ -690,17 +873,15 @@ sub create_unique_sesion_value { my $key = "$$-" . ($now[0] * 1000000 + $now[1]) . "-"; $self->{unique_counter} ||= 0; - $self->{unique_counter}++ while exists $self->{SESSION}->{$key . $self->{unique_counter}}; - $self->{unique_counter}++; + my $hashed_key; + do { + $self->{unique_counter}++; + $hashed_key = md5_hex($key . $self->{unique_counter}); + } while (exists $self->{SESSION}->{$hashed_key}); - $value = { expiration => $params{expiration} ? ($now[0] + $params{expiration}) * 1000000 + $now[1] : undef, - no_auto => !$params{auto_restore}, - data => $value, - }; + $self->set_session_value($hashed_key => $value); - $self->{SESSION}->{$key . $self->{unique_counter}} = YAML::Dump($value); - - return $key . $self->{unique_counter}; + return $hashed_key; } sub save_form_in_session { @@ -733,27 +914,6 @@ sub restore_form_from_session { return $self; } -sub expire_session_keys { - my ($self) = @_; - - $self->{SESSION} ||= { }; - - my @now = gettimeofday(); - my $now = $now[0] * 1000000 + $now[1]; - - $self->delete_session_value(map { $_->[0] } - grep { $_->[1]->{expiration} && ($now > $_->[1]->{expiration}) } - map { [ $_, $self->_load_value($self->{SESSION}->{$_}) ] } - keys %{ $self->{SESSION} }); - - return $self; -} - -sub _has_expiration { - my ($value) = @_; - return (ref $value eq 'HASH') && exists($value->{expiration}) && $value->{data}; -} - sub set_cookie_environment_variable { my $self = shift; $ENV{HTTP_COOKIE} = $self->get_session_cookie_name() . "=${session_id}"; @@ -773,6 +933,14 @@ sub session_tables_present { $main::lxdebug->enter_sub(); my $self = shift; + + # Only re-check for the presence of auth tables if either the check + # hasn't been done before of if they weren't present. + if ($self->{session_tables_present}) { + $main::lxdebug->leave_sub(); + return $self->{session_tables_present}; + } + my $dbh = $self->dbconnect(1); if (!$dbh) { @@ -788,9 +956,11 @@ sub session_tables_present { my ($count) = selectrow_query($main::form, $dbh, $query); + $self->{session_tables_present} = 2 == $count; + $main::lxdebug->leave_sub(); - return 2 == $count; + return $self->{session_tables_present}; } # -------------------------------------- @@ -814,10 +984,10 @@ sub all_rights_full { ["crm_notices", $locale->text("CRM notices")], ["crm_other", $locale->text("CRM other")], ["--master_data", $locale->text("Master Data")], - ["customer_vendor_edit", $locale->text("Create and edit customers and vendors")], + ["customer_vendor_edit", $locale->text("Create customers and vendors. Edit all vendors. Edit only customers where salesman equals employee (login)")], + ["customer_vendor_all_edit", $locale->text("Create customers and vendors. Edit all vendors. Edit all customers")], ["part_service_assembly_edit", $locale->text("Create and edit parts, services, assemblies")], ["project_edit", $locale->text("Create and edit projects")], - ["license_edit", $locale->text("Manage license keys")], ["--ar", $locale->text("AR")], ["sales_quotation_edit", $locale->text("Create and edit sales quotations")], ["sales_order_edit", $locale->text("Create and edit sales orders")], @@ -825,6 +995,7 @@ sub all_rights_full { ["invoice_edit", $locale->text("Create and edit invoices and credit notes")], ["dunning_edit", $locale->text("Create and edit dunnings")], ["sales_all_edit", $locale->text("View/edit all employees sales documents")], + ["edit_prices", $locale->text("Edit prices and discount (if not used, textfield is ONLY set readonly)")], ["--ap", $locale->text("AP")], ["request_quotation_edit", $locale->text("Create and edit RFQs")], ["purchase_order_edit", $locale->text("Create and edit purchase orders")], @@ -845,6 +1016,7 @@ sub all_rights_full { ["--others", $locale->text("Others")], ["email_bcc", $locale->text("May set the BCC field when sending emails")], ["config", $locale->text("Change Lx-Office installation settings (all menu entries beneath 'System')")], + ["admin", $locale->text("Administration (Used to access instance administration from user logins)")], ); return @all_rights; @@ -1086,25 +1258,20 @@ sub check_right { } sub assert { - $main::lxdebug->enter_sub(2); - - my $self = shift; - my $right = shift; - my $dont_abort = shift; + $::lxdebug->enter_sub(2); + my ($self, $right, $dont_abort) = @_; - my $form = $main::form; - - if ($self->check_right($form->{login}, $right)) { - $main::lxdebug->leave_sub(2); + if ($self->check_right($::myconfig{login}, $right)) { + $::lxdebug->leave_sub(2); return 1; } if (!$dont_abort) { - delete $form->{title}; - $form->show_generic_error($main::locale->text("You do not have the permissions to access this function.")); + delete $::form->{title}; + $::form->show_generic_error($::locale->text("You do not have the permissions to access this function.")); } - $main::lxdebug->leave_sub(2); + $::lxdebug->leave_sub(2); return 0; } @@ -1116,7 +1283,7 @@ sub load_rights_for_user { my $dbh = $self->dbconnect; my ($query, $sth, $row, $rights); - $rights = { map { $rights->{$_} = 0 } all_rights() }; + $rights = { map { $_ => 0 } all_rights() }; $query = qq|SELECT gr."right", gr.granted @@ -1154,11 +1321,31 @@ SL::Auth - Authentication and session handling =over 4 +=item C + =item C -Store all key/value pairs in C<%values> in the session. All of these -values are copied back into C<$::form> in the next request -automatically. +Store all values of C<@values> or C<%values> in the session. Each +member of C<@values> is tested if it is a hash reference. If it is +then it must contain the keys C and C and can optionally +contain the key C. In this case C is associated +with C and restored to C<$::form> upon the next request +automatically if C is trueish or if C is a scalar +value. + +If the current member of C<@values> is not a hash reference then it +will be used as the C and the next entry of C<@values> is used as +the C to store. In this case setting C is not +possible. + +Therefore the following two invocations are identical: + + $::auth-Eset_session_value(name =E "Charlie"); + $::auth-Eset_session_value({ key =E "name", value =E "Charlie" }); + +All of these values are copied back into C<$::form> for the next +request automatically if they're scalar values or if they have +C set to trueish. The values can be any Perl structure. They are stored as YAML dumps. @@ -1172,22 +1359,8 @@ doesn't exist. Create a unique key in the session and store C<$value> there. -If C<$params{expiration}> is set then it is interpreted as a number of -seconds after which the value is removed from the session. It will -never expire if that parameter is falsish. - -If C<$params{auto_restore}> is trueish then the value will be copied -into C<$::form> upon the next request automatically. It defaults to -C and has therefore different behaviour than -L. - Returns the key created in the session. -=item C - -Removes all keys from the session that have an expiration time set and -whose expiration time is in the past. - =item C Stores the session values in the database. This is the only function