/ - Diff - projekt kivitendo - wissen

« Zurück | Weiter »

Revision 8c7e4493

Von Moritz Bunkus vor fast 17 Jahren hinzugefügt

ID 8c7e44938a661e035f62840e1e177353240ace5d
Vorgänger 3ced230b
Nachfolger ce45d060

Umstellung der Benutzerverwaltung von Dateien im Verzeichnis "users" auf die Verwendung einer Authentifizierungsdatenbank.
Es ist erforderlich, die Dateien doc/UPGRADE und doc/INSTALL/index.html zu lesen und die angesprochenen Punkte auszuführen, um nach einem Upgrade weiter arbeiten zu können.

     package AM;
     use Carp;
     use Data::Dumper;
     use SL::DBUtils;
-...
     sub save_preferences {
       $main::lxdebug->enter_sub();
       my ($self, $myconfig, $form, $memberfile, $userspath, $webdav) = @_;
       my ($self, $myconfig, $form, $webdav) = @_;
       my $dbh = $form->get_standard_dbh($myconfig);
-...
       $form->{businessnumber} =  $businessnumber;
       $myconfig = new User "$memberfile", "$form->{login}";
       my $myconfig = new User($form->{login});
       foreach my $item (keys %$form) {
         $myconfig->{$item} = $form->{$item};
+      }
       $myconfig->save_member($memberfile, $userspath);
       $myconfig->save_member($memberfile);
       my $auth = $main::auth;
       if ($auth->can_change_password()
           && defined $form->{new_password}
           && ($form->{new_password} ne '********')) {
         $auth->change_password($form->{login}, $form->{new_password});
         $form->{password} = $form->{new_password};
         $auth->set_session_value('password', $form->{password});
         $auth->create_or_refresh_session();
+      }
       if ($webdav) {
         @webdavdirs =
-...
       return $units;
+    }
     sub retrieve_all_units {
       $main::lxdebug->enter_sub();
       my $self = shift;
       if (!$main::all_units) {
         $main::all_units = $self->retrieve_units(\%main::myconfig, $main::form);
+      }
       $main::lxdebug->leave_sub();
       return $main::all_units;
+    }
     sub translate_units {
       $main::lxdebug->enter_sub();
-...
       $main::lxdebug->leave_sub();
+    }
     sub convertible_units {
       $main::lxdebug->enter_sub();
       my $self        = shift;
       my $units       = shift;
       my $filter_unit = shift;
       my $not_smaller = shift;
       my $conv_units = [];
       $filter_unit = $units->{$filter_unit};
       foreach my $name (sort { lc $a cmp lc $b } keys %{ $units }) {
         my $unit = $units->{$name};
         if (($unit->{base_unit} eq $filter_unit->{base_unit}) &&
             (!$not_smaller || ($unit->{factor} >= $filter_unit->{factor}))) {
           push @{$conv_units}, $unit;
+        }
+      }
       my @sorted = sort { $b->{factor} <=> $a->{factor} } @{ $conv_units };
       $main::lxdebug->leave_sub();
       return \@sorted;
+    }
     # if $a is translatable to $b, return the factor between them.
     # else return 1
     sub convert_unit {
-...
     sub unit_select_data {
       $main::lxdebug->enter_sub();
       my ($self, $units, $selected, $empty_entry) = @_;
       my ($self, $units, $selected, $empty_entry, $convertible_into) = @_;
       my $select = [];
-...
+      }
       foreach my $unit (sort({ $units->{$a}->{"sortkey"} <=> $units->{$b}->{"sortkey"} } keys(%{$units}))) {
         push(@{$select}, { "name" => $unit,
                            "base_unit" => $units->{$unit}->{"base_unit"},
                            "factor" => $units->{$unit}->{"factor"},
                            "selected" => ($unit eq $selected) ? "selected" : "" });
         if (!$convertible_into ||
             ($units->{$convertible_into} &&
              ($units->{$convertible_into}->{base_unit} eq $units->{$unit}->{base_unit}))) {
           push @{$select}, { "name"      => $unit,
                              "base_unit" => $units->{$unit}->{"base_unit"},
                              "factor"    => $units->{$unit}->{"factor"},
                              "selected"  => ($unit eq $selected) ? "selected" : "" };
+        }
+      }
       $main::lxdebug->leave_sub();
-...
       return $select;
+    }
     sub sum_with_unit {
       $main::lxdebug->enter_sub();
       my $self  = shift;
       my $units = $self->retrieve_all_units();
       my $sum   = 0;
       my $base_unit;
       while (2 <= scalar(@_)) {
         my $qty  = shift(@_);
         my $unit = $units->{shift(@_)};
         croak "No unit defined with name $unit" if (!defined $unit);
         if (!$base_unit) {
           $base_unit = $unit->{base_unit};
         } elsif ($base_unit ne $unit->{base_unit}) {
           croak "Adding values with incompatible base units $base_unit/$unit->{base_unit}";
+        }
         $sum += $qty * $unit->{factor};
+      }
       $main::lxdebug->leave_sub();
       return wantarray ? ($sum, $baseunit) : $sum;
+    }
     sub add_unit {
       $main::lxdebug->enter_sub();

     package SL::Auth;
     use constant OK           =>   0;
     use constant ERR_PASSWORD =>   1;
     use constant ERR_BACKEND  => 100;
     use Digest::MD5 qw(md5_hex);
     use IO::File;
     use Time::HiRes qw(gettimeofday);
     use SL::Auth::DB;
     use SL::Auth::LDAP;
     use SL::User;
     use SL::DBUtils;
     sub new {
       $main::lxdebug->enter_sub();
       my $type = shift;
       my $self = {};
       bless $self, $type;
       $self->{SESSION} = { };
       $self->_read_auth_config();
       $main::lxdebug->leave_sub();
       return $self;
+    }
     sub DESTROY {
       my $self = shift;
       $self->{dbh}->disconnect() if ($self->{dbh});
+    }
     sub _read_auth_config {
       $main::lxdebug->enter_sub();
       my $self   = shift;
       my $form   = $main::form;
       my $locale = $main::locale;
       my $code;
       my $in = IO::File->new('config/authentication.pl', 'r');
       if (!$in) {
         $form->error($locale->text('The config file "config/authentication.pl" was not found.'));
+      }
       while (<$in>) {
         $code .= $_;
+      }
       $in->close();
       eval $code;
       if ($@) {
         $form->error($locale->text('The config file "config/authentication.pl" contained invalid Perl code:') . "\n" . $@);
+      }
       if ($self->{module} eq 'DB') {
         $self->{authenticator} = SL::Auth::DB->new($self);
       } elsif ($self->{module} eq 'LDAP') {
         $self->{authenticator} = SL::Auth::LDAP->new($self);
+      }
       if (!$self->{authenticator}) {
         $form->error($locale->text('No or an unknown authenticantion module specified in "config/authentication.pl".'));
+      }
       my $cfg = $self->{DB_config};
       if (!$cfg) {
         $form->error($locale->text('config/authentication.pl: Key "DB_config" is missing.'));
+      }
       if (!$cfg->{host} || !$cfg->{db} || !$cfg->{user}) {
         $form->error($locale->text('config/authentication.pl: Missing parameters in "DB_config". Required parameters are "host", "db" and "user".'));
+      }
       $self->{authenticator}->verify_config();
       $main::lxdebug->leave_sub();
+    }
     sub authenticate_root {
       $main::lxdebug->enter_sub();
       my $self          = shift;
       my $password      = shift;
       my $is_crypted    = shift;
       $password         = crypt $password, 'ro' if (!$password || !$is_crypted);
       $admin_password   = crypt "$self->{admin_password}", 'ro';
       $main::lxdebug->leave_sub();
       return $password eq $admin_password ? OK : ERR_PASSWORD;
+    }
     sub authenticate {
       $main::lxdebug->enter_sub();
       my $self = shift;
       $main::lxdebug->leave_sub();
       return $self->{authenticator}->authenticate(@_);
+    }
     sub dbconnect {
       $main::lxdebug->enter_sub();
       my $self     = shift;
       my $may_fail = shift;
       if ($self->{dbh}) {
         $main::lxdebug->leave_sub();
         return $self->{dbh};
+      }
       my $cfg = $self->{DB_config};
       my $dsn = 'dbi:Pg:dbname=' . $cfg->{db} . ';host=' . $cfg->{host};
       if ($cfg->{port}) {
         $dsn .= ';port=' . $cfg->{port};
+      }
       $main::lxdebug->message(LXDebug::DEBUG1, "Auth::dbconnect DSN: $dsn");
       $self->{dbh} = DBI->connect($dsn, $cfg->{user}, $cfg->{password}, { 'AutoCommit' => 0 });
       if (!$may_fail && !$self->{dbh}) {
         $main::form->error($main::locale->text('The connection to the authentication database failed:') . "\n" . $DBI::errstr);
+      }
       $main::lxdebug->leave_sub();
       return $self->{dbh};
+    }
     sub dbdisconnect {
       $main::lxdebug->enter_sub();
       my $self = shift;
       if ($self->{dbh}) {
         $self->{dbh}->disconnect();
         delete $self->{dbh};
+      }
       $main::lxdebug->leave_sub();
+    }
     sub check_tables {
       $main::lxdebug->enter_sub();
       my $self    = shift;
       my $dbh     = $self->dbconnect();
       my $query   = qq|SELECT COUNT(*) FROM pg_tables WHERE (schemaname = 'auth') AND (tablename = 'user')|;
       my ($count) = $dbh->selectrow_array($query);
       $main::lxdebug->leave_sub();
       return $count > 0;
+    }
     sub check_database {
       $main::lxdebug->enter_sub();
       my $self = shift;
       my $dbh  = $self->dbconnect(1);
       $main::lxdebug->leave_sub();
       return $dbh ? 1 : 0;
+    }
     sub create_database {
       $main::lxdebug->enter_sub();
       my $self   = shift;
       my %params = @_;
       my $cfg    = $self->{DB_config};
       if (!$params{superuser}) {
         $params{superuser}          = $cfg->{user};
         $params{superuser_password} = $cfg->{password};
+      }
       $params{template} ||= 'template0';
       $params{template}   =~ s|[^a-zA-Z0-9_\-]||g;
       my $dsn = 'dbi:Pg:dbname=template1;host=' . $cfg->{host};
       if ($cfg->{port}) {
         $dsn .= ';port=' . $cfg->{port};
+      }
       $main::lxdebug->message(LXDebug::DEBUG1, "Auth::create_database DSN: $dsn");
       my $dbh = DBI->connect($dsn, $params{superuser}, $params{superuser_password});
       if (!$dbh) {
         $main::form->error($main::locale->text('The connection to the template database failed:') . "\n" . $DBI::errstr);
+      }
       my $charset    = $main::charset;
       $charset     ||= Common::DEFAULT_CHARSET;
       my $encoding   = $Common::charset_to_db_encoding{$charset};
       $encoding    ||= 'UNICODE';
       my $query = qq|CREATE DATABASE "$cfg->{db}" OWNER "$cfg->{user}" TEMPLATE "$params{template}" ENCODING '$encoding'|;
       $main::lxdebug->message(LXDebug::DEBUG1, "Auth::create_database query: $query");
       $dbh->do($query);
       if ($dbh->err) {
         $dbh->disconnect();
         $main::form->error($main::locale->text('The creation of the authentication database failed:') . "\n" . $DBI::errstr);
+      }
       $dbh->disconnect();
       $main::lxdebug->leave_sub();
+    }
     sub create_tables {
       $main::lxdebug->enter_sub();
       my $self = shift;
       my $dbh  = $self->dbconnect();
       my $charset    = $main::charset;
       $charset     ||= Common::DEFAULT_CHARSET;
       $dbh->rollback();
       User->process_query($main::form, $dbh, 'sql/auth_db.sql', undef, $charset);
       $main::lxdebug->leave_sub();
+    }
     sub save_user {
       $main::lxdebug->enter_sub();
       my $self   = shift;
       my $login  = shift;
       my %params = @_;
       my $form   = $main::form;
       my $dbh    = $self->dbconnect();
       my ($sth, $query, $user_id);
       $query     = qq|SELECT id FROM auth."user" WHERE login = ?|;
       ($user_id) = selectrow_query($form, $dbh, $query, $login);
       if (!$user_id) {
         $query     = qq|SELECT nextval('auth.user_id_seq')|;
         ($user_id) = selectrow_query($form, $dbh, $query);
         $query     = qq|INSERT INTO auth."user" (id, login) VALUES (?, ?)|;
         do_query($form, $dbh, $query, $user_id, $login);
+      }
       $query = qq|DELETE FROM auth.user_config WHERE (user_id = ?)|;
       do_query($form, $dbh, $query, $user_id);
       $query = qq|INSERT INTO auth.user_config (user_id, cfg_key, cfg_value) VALUES (?, ?, ?)|;
       $sth   = prepare_query($form, $dbh, $query);
       while (my ($cfg_key, $cfg_value) = each %params) {
         next if ($cfg_key eq 'password');
         do_statement($form, $sth, $query, $user_id, $cfg_key, $cfg_value);
+      }
       $dbh->commit();
       $main::lxdebug->leave_sub();
+    }
     sub can_change_password {
       my $self = shift;
       return $self->{authenticator}->can_change_password();
+    }
     sub change_password {
       $main::lxdebug->enter_sub();
       my $self   = shift;
       my $result = $self->{authenticator}->change_password(@_);
       $main::lxdebug->leave_sub();
       return $result;
+    }
     sub read_all_users {
       $main::lxdebug->enter_sub();
       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 $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}}->{$ref->{cfg_key}}   = $ref->{cfg_value} if (($cfg_key ne 'login') && ($cfg_key ne 'id'));
+      }
       $sth->finish();
       $main::lxdebug->leave_sub();
       return %users;
+    }
     sub read_user {
       $main::lxdebug->enter_sub();
       my $self  = shift;
       my $login = shift;
       my $dbh   = $self->dbconnect();
       my $query = qq|SELECT 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);
       my %user_data;
       while (my $ref = $sth->fetchrow_hashref()) {
         $user_data{$ref->{cfg_key}} = $ref->{cfg_value};
         $user_data{login}           = $login;
+      }
       $sth->finish();
       $main::lxdebug->leave_sub();
       return %user_data;
+    }
     sub get_user_id {
       $main::lxdebug->enter_sub();
       my $self  = shift;
       my $login = shift;
       my $dbh   = $self->dbconnect();
       my ($id)  = selectrow_query($main::form, $dbh, qq|SELECT id FROM auth."user" WHERE login = ?|, $login);
       $main::lxdebug->leave_sub();
       return $id;
+    }
     sub delete_user {
       $main::lxdebug->enter_sub();
       my $self  = shift;
       my $login = shift;
       my $form  = $main::form;
       my $dbh   = $self->dbconnect();
       my $query = qq|SELECT id FROM auth."user" WHERE login = ?|;
       my ($id)  = selectrow_query($form, $dbh, $query, $login);
       return $main::lxdebug->leave_sub() if (!$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);
       $dbh->commit();
       $main::lxdebug->leave_sub();
+    }
     # --------------------------------------
     my $session_id;
     sub restore_session {
       $main::lxdebug->enter_sub();
       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;
       $self->{SESSION}   = { };
       return $main::lxdebug->leave_sub() if (!$session_id);
       my ($dbh, $query, $sth, $cookie, $ref, $form);
       $form   = $main::form;
       $dbh    = $self->dbconnect();
       $query  = qq|SELECT *, (mtime < (now() - '24h'::interval)) AS is_expired FROM auth.session WHERE id = ?|;
       $cookie = selectfirst_hashref_query($form, $dbh, $query, $session_id);
       if (!$cookie || $cookie->{is_expired} || ($cookie->{ip_address} ne $ENV{REMOTE_ADDR})) {
         $self->destroy_session();
         $main::lxdebug->leave_sub();
         return;
+      }
       $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};
         $form->{$ref->{sess_key}}            = $ref->{sess_value} if (!defined $form->{$ref->{sess_key}});
+      }
       $sth->finish();
       $main::lxdebug->leave_sub();
+    }
     sub destroy_session {
       $main::lxdebug->enter_sub();
       my $self = shift;
       if ($session_id) {
         my $dbh = $self->dbconnect();
         do_query($main::form, $dbh, qq|DELETE FROM auth.session_content WHERE session_id = ?|, $session_id);
         do_query($main::form, $dbh, qq|DELETE FROM auth.session WHERE id = ?|, $session_id);
         $dbh->commit();
         $session_id      = undef;
         $self->{SESSION} = { };
+      }
       $main::lxdebug->leave_sub();
+    }
     sub expire_sessions {
       $main::lxdebug->enter_sub();
       my $self  = shift;
       my $dbh   = $self->dbconnect();
       my $query =
         qq|DELETE FROM auth.session_content
            WHERE session_id IN
              (SELECT id
               FROM auth.session
               WHERE (mtime < (now() - '24h'::interval)))|;
       do_query($main::form, $dbh, $query);
       $query =
         qq|DELETE FROM auth.session
            WHERE (mtime < (now() - '24h'::interval))|;
       do_query($main::form, $dbh, $query);
       $dbh->commit();
       $main::lxdebug->leave_sub();
+    }
     sub _create_session_id {
       $main::lxdebug->enter_sub();
       my @secs = gettimeofday();
       srand $secs[1] + $$;
       my @data;
       map { push @data, int(rand() * 255); } (1..32);
       my $id = md5_hex(pack 'C*', @data);
       $main::lxdebug->leave_sub();
       return $id;
+    }
     sub create_or_refresh_session {
       $main::lxdebug->enter_sub();
       my $self = shift;
       $session_id ||= $self->_create_session_id();
       my ($form, $dbh, $query, $sth, $id);
       $form  = $main::form;
       $dbh   = $self->dbconnect();
       $query = qq|SELECT id FROM auth.session WHERE id = ?|;
       ($id)  = selectrow_query($form, $dbh, $query, $session_id);
       if ($id) {
         do_query($form, $dbh, qq|UPDATE auth.session SET mtime = now() WHERE id = ?|, $session_id);
         do_query($form, $dbh, qq|DELETE FROM auth.session_content WHERE session_id = ?|, $session_id);
       } else {
         do_query($form, $dbh, qq|INSERT INTO auth.session (id, ip_address, mtime) VALUES (?, ?, now())|, $session_id, $ENV{REMOTE_ADDR});
+      }
       $query = qq|INSERT INTO auth.session_content (session_id, sess_key, sess_value) VALUES (?, ?, ?)|;
       $sth   = prepare_query($form, $dbh, $query);
       foreach my $key (sort keys %{ $self->{SESSION} }) {
         do_statement($form, $sth, $query, $session_id, $key, $self->{SESSION}->{$key});
+      }
       $sth->finish();
       $dbh->commit();
       $main::lxdebug->leave_sub();
+    }
     sub set_session_value {
       $main::lxdebug->enter_sub();
       my $self  = shift;
       $self->{SESSION} ||= { };
       while (2 <= scalar @_) {
         my $key   = shift;
         my $value = shift;
         $self->{SESSION}->{$key} = $value;
+      }
       $main::lxdebug->leave_sub();
+    }
     sub set_cookie_environment_variable {
       my $self = shift;
       $ENV{HTTP_COOKIE} = $self->get_session_cookie_name() . "=${session_id}";
+    }
     sub get_session_cookie_name {
       my $self = shift;
       return $self->{cookie_name} || 'lx_office_erp_session_id';
+    }
     sub get_session_id {
       return $session_id;
+    }
     sub session_tables_present {
       $main::lxdebug->enter_sub();
       my $self = shift;
       my $dbh  = $self->dbconnect(1);
       if (!$dbh) {
         $main::lxdebug->leave_sub();
         return 0;
+      }
       my $query =
         qq|SELECT COUNT(*)
            FROM pg_tables
            WHERE (schemaname = 'auth')
              AND (tablename IN ('session', 'session_content'))|;
       my ($count) = selectrow_query($main::form, $dbh, $query);
       $main::lxdebug->leave_sub();
       return 2 == $count;
+    }
     # --------------------------------------
     sub all_rights_full {
       my $locale = $main::locale;
       my @all_rights = (
         ["--master_data",                  $locale->text("Master Data")],
         ["customer_vendor_edit",           $locale->text("Create and edit customers and vendors")],
         ["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")],
         ["sales_delivery_order_edit",      $locale->text("Create and edit sales delivery orders")],
         ["invoice_edit",                   $locale->text("Create and edit invoices and credit notes")],
         ["dunning_edit",                   $locale->text("Create and edit dunnings")],
         ["--ap",                           $locale->text("AP")],
         ["request_quotation_edit",         $locale->text("Create and edit RFQs")],
         ["purchase_order_edit",            $locale->text("Create and edit purchase orders")],
         ["purchase_delivery_order_edit",   $locale->text("Create and edit purchase delivery orders")],
         ["vendor_invoice_edit",            $locale->text("Create and edit vendor invoices")],
         ["--general_ledger_cash",          $locale->text("General ledger and cash")],
         ["general_ledger",                 $locale->text("Transactions, AR transactions, AP transactions")],
         ["datev_export",                   $locale->text("DATEV Export")],
         ["cash",                           $locale->text("Receipt, payment, reconciliation")],
         ["--reports",                      $locale->text('Reports')],
         ["report",                         $locale->text('All reports')],
         ["advance_turnover_tax_return",    $locale->text('Advance turnover tax return')],
         ["--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')")],
         );
       return @all_rights;
+    }
     sub all_rights {
       return grep !/^--/, map { $_->[0] } all_rights_full();
+    }
     sub read_groups {
       $main::lxdebug->enter_sub();
       my $self = shift;
       my $form   = $main::form;
       my $groups = {};
       my $dbh    = $self->dbconnect();
       my $query  = 'SELECT * FROM auth."group"';
       my $sth    = prepare_execute_query($form, $dbh, $query);
       my ($row, $group);
       while ($row = $sth->fetchrow_hashref()) {
         $groups->{$row->{id}} = $row;
+      }
       $sth->finish();
       $query = 'SELECT * FROM auth.user_group WHERE group_id = ?';
       $sth   = prepare_query($form, $dbh, $query);
       foreach $group (values %{$groups}) {
         $group->{members} = [];
         do_statement($form, $sth, $query, $group->{id});
         while ($row = $sth->fetchrow_hashref()) {
           push @{$group->{members}}, $row->{user_id};
+        }
+      }
       $sth->finish();
       $query = 'SELECT * FROM auth.group_rights WHERE group_id = ?';
       $sth   = prepare_query($form, $dbh, $query);
       foreach $group (values %{$groups}) {
         $group->{rights} = {};
         do_statement($form, $sth, $query, $group->{id});
         while ($row = $sth->fetchrow_hashref()) {
           $group->{rights}->{$row->{right}} |= $row->{granted};
+        }
         map { $group->{rights}->{$_} = 0 if (!defined $group->{rights}->{$_}); } all_rights();
+      }
       $sth->finish();
       $main::lxdebug->leave_sub();
       return $groups;
+    }
     sub save_group {
       $main::lxdebug->enter_sub();
       my $self  = shift;
       my $group = shift;
       my $form  = $main::form;
       my $dbh   = $self->dbconnect();
       my ($query, $sth, $row, $rights);
       if (!$group->{id}) {
         ($group->{id}) = selectrow_query($form, $dbh, qq|SELECT nextval('auth.group_id_seq')|);
         $query = qq|INSERT INTO auth."group" (id, name, description) VALUES (?, '', '')|;
         do_query($form, $dbh, $query, $group->{id});
+      }
       do_query($form, $dbh, qq|UPDATE auth."group" SET name = ?, description = ? WHERE id = ?|, map { $group->{$_} } qw(name description id));
       do_query($form, $dbh, qq|DELETE FROM auth.user_group WHERE group_id = ?|, $group->{id});
       $query  = qq|INSERT INTO auth.user_group (user_id, group_id) VALUES (?, ?)|;
       $sth    = prepare_query($form, $dbh, $query);
       foreach my $user_id (@{ $group->{members} }) {
         do_statement($form, $sth, $query, $user_id, $group->{id});
+      }
       $sth->finish();
       do_query($form, $dbh, qq|DELETE FROM auth.group_rights WHERE group_id = ?|, $group->{id});
       $query = qq|INSERT INTO auth.group_rights (group_id, "right", granted) VALUES (?, ?, ?)|;
       $sth   = prepare_query($form, $dbh, $query);
       foreach my $right (keys %{ $group->{rights} }) {
         do_statement($form, $sth, $query, $group->{id}, $right, $group->{rights}->{$right} ? 't' : 'f');
+      }
       $sth->finish();
       $dbh->commit();
       $main::lxdebug->leave_sub();
+    }
     sub delete_group {
       $main::lxdebug->enter_sub();
       my $self = shift;
       my $id   = shift;
       my $form = $main::from;
       my $dbh  = $self->dbconnect();
       do_query($form, $dbh, qq|DELETE FROM auth.user_group WHERE group_id = ?|, $id);
       do_query($form, $dbh, qq|DELETE FROM auth.group_rights WHERE group_id = ?|, $id);
       do_query($form, $dbh, qq|DELETE FROM auth."group" WHERE id = ?|, $id);
       $dbh->commit();
       $main::lxdebug->leave_sub();
+    }
     sub evaluate_rights_ary {
       $main::lxdebug->enter_sub(2);
       my $ary    = shift;
       my $value  = 0;
       my $action = '|';
       foreach my $el (@{$ary}) {
         if (ref $el eq "ARRAY") {
           if ($action eq '|') {
             $value |= evaluate_rights_ary($el);
           } else {
             $value &= evaluate_rights_ary($el);
+          }
         } elsif (($el eq '&') || ($el eq '|')) {
           $action = $el;
         } elsif ($action eq '|') {
           $value |= $el;
         } else {
           $value &= $el;
+        }
+      }
       $main::lxdebug->enter_sub(2);
       return $value;
+    }
     sub _parse_rights_string {
       $main::lxdebug->enter_sub(2);
       my $self   = shift;
       my $login  = shift;
       my $access = shift;
       my @stack;
       my $cur_ary = [];
       push @stack, $cur_ary;
       while ($access =~ m/^([a-z_0-9]+|\||\&|\(|\)|\s+)/) {
         my $token = $1;
         substr($access, 0, length $1) = "";
         next if ($token =~ /\s/);
         if ($token eq "(") {
           my $new_cur_ary = [];
           push @stack, $new_cur_ary;
           push @{$cur_ary}, $new_cur_ary;
           $cur_ary = $new_cur_ary;
         } elsif ($token eq ")") {
           pop @stack;
           if (!@stack) {
             $main::lxdebug->enter_sub(2);
             return 0;
+          }
           $cur_ary = $stack[-1];
         } elsif (($token eq "|") || ($token eq "&")) {
           push @{$cur_ary}, $token;
         } else {
           push @{$cur_ary}, $self->{RIGHTS}->{$login}->{$token} * 1;
+        }
+      }
       my $result = ($access || (1 < scalar @stack)) ? 0 : evaluate_rights_ary($stack[0]);
       $main::lxdebug->enter_sub(2);
       return $result;
+    }
     sub check_right {
       $main::lxdebug->enter_sub(2);
       my $self    = shift;
       my $login   = shift;
       my $right   = shift;
       my $default = shift;
       $self->{FULL_RIGHTS}           ||= { };
       $self->{FULL_RIGHTS}->{$login} ||= { };
       if (!defined $self->{FULL_RIGHTS}->{$login}->{$right}) {
         $self->{RIGHTS}           ||= { };
         $self->{RIGHTS}->{$login} ||= $self->load_rights_for_user($login);
         $self->{FULL_RIGHTS}->{$login}->{$right} = $self->_parse_rights_string($login, $right);
+      }
       my $granted = $self->{FULL_RIGHTS}->{$login}->{$right};
       $granted    = $default if (!defined $granted);
       $main::lxdebug->leave_sub(2);
       return $granted;
+    }
     sub assert {
       $main::lxdebug->enter_sub(2);
       my $self       = shift;
       my $right      = shift;
       my $dont_abort = shift;
       my $form       = $main::form;
       if ($self->check_right($form->{login}, $right)) {
         $main::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."));
+      }
       $main::lxdebug->leave_sub(2);
       return 0;
+    }
     sub load_rights_for_user {
       $main::lxdebug->enter_sub();
       my $self  = shift;
       my $login = shift;
       my $form  = $main::form;
       my $dbh   = $self->dbconnect();
       my ($query, $sth, $row, $rights);
       $rights = {};
       $query =
         qq|SELECT gr."right", gr.granted
            FROM auth.group_rights gr
            WHERE group_id IN
              (SELECT ug.group_id
               FROM auth.user_group ug
               LEFT JOIN auth."user" u ON (ug.user_id = u.id)
               WHERE u.login = ?)|;
       $sth = prepare_execute_query($form, $dbh, $query, $login);
       while ($row = $sth->fetchrow_hashref()) {
         $rights->{$row->{right}} |= $row->{granted};
+      }
       $sth->finish();
       map({ $rights->{$_} = 0 unless (defined $rights->{$_}); } SL::Auth::all_rights());
       $main::lxdebug->leave_sub();
       return $rights;
+    }
 ;

     package SL::Auth::DB;
     use DBI;
     use SL::Auth;
     use SL::DBUtils;
     sub new {
       $main::lxdebug->enter_sub();
       my $type = shift;
       my $self = {};
       $self->{auth} = shift;
       bless $self, $type;
       $main::lxdebug->leave_sub();
       return $self;
+    }
     sub authenticate {
       $main::lxdebug->enter_sub();
       my $self       = shift;
       my $login      = shift;
       my $password   = shift;
       my $is_crypted = shift;
       my $dbh        = $self->{auth}->dbconnect();
       if (!$dbh) {
         $main::lxdebug->leave_sub();
         return SL::Auth::ERR_BACKEND;
+      }
       my $query             = qq|SELECT password FROM auth."user" WHERE login = ?|;
       my ($stored_password) = $dbh->selectrow_array($query, undef, $login);
       $password        = crypt $password, substr($login, 0, 2)        if (!$password || !$is_crypted);
       $stored_password = crypt $stored_password, substr($login, 0, 2) if (!$stored_password);
       $main::lxdebug->leave_sub();
       return $password eq $stored_password ? SL::Auth::OK : SL::Auth::ERR_PASSWORD;
+    }
     sub can_change_password {
       return 1;
+    }
     sub change_password {
       $main::lxdebug->enter_sub();
       my $self       = shift;
       my $login      = shift;
       my $password   = shift;
       my $is_crypted = shift;
       my $dbh        = $self->{auth}->dbconnect();
       if (!$dbh) {
         $main::lxdebug->leave_sub();
         return SL::Auth::ERR_BACKEND
+      }
       $password = crypt $password, substr($login, 0, 2) if (!$is_crypted);
       do_query($main::form, $dbh, qq|UPDATE auth."user" SET password = ? WHERE login = ?|, $password, $login);
       $dbh->commit();
       $main::lxdebug->leave_sub();
       return 1;
+    }
     sub verify_config {
       return 1;
+    }
 ;

     package SL::Auth::LDAP;
     use English '-no_match_vars';
     use SL::Auth;
     sub new {
       $main::lxdebug->enter_sub();
       if (!defined eval "require Net::LDAP;") {
         die 'The module "Net::LDAP" is not installed.';
+      }
       my $type = shift;
       my $self = {};
       $self->{auth} = shift;
       bless $self, $type;
       $main::lxdebug->leave_sub();
       return $self;
+    }
     sub _connect {
       $main::lxdebug->enter_sub();
       my $self = shift;
       my $cfg  = $self->{auth}->{LDAP_config};
       if ($self->{ldap}) {
         $main::lxdebug->leave_sub();
         return $self->{ldap};
+      }
       my $port      = $cfg->{port} || 389;
       $self->{ldap} = Net::LDAP->new($cfg->{host}, 'port' => $port);
       if (!$self->{ldap}) {
         $main::form->error($main::locale->text('The LDAP server "#1:#2" is unreachable. Please check config/authentication.pl.', $cfg->{host}, $port));
+      }
       if ($cfg->{tls}) {
         my $mesg = $self->{ldap}->start_tls('verify' => 'none');
         if ($mesg->is_error()) {
           $main::form->error($main::locale->text('The connection to the LDAP server cannot be encrypted (SSL/TLS startup failure). Please check config/authentication.pl.'));
+        }
+      }
       if ($cfg->{bind_dn}) {
         my $mesg = $self->{ldap}->bind($cfg->{bind_dn}, 'password' => $cfg->{bind_password});
         if ($mesg->is_error()) {
           $main::form->error($main::locale->text('Binding to the LDAP server as "#1" failed. Please check config/authentication.pl.', $cfg->{bind_dn}));
+        }
+      }
       $main::lxdebug->leave_sub();
       return $self->{ldap};
+    }
     sub _get_filter {
       $main::lxdebug->enter_sub();
       my $self   = shift;
       my $login  = shift;
       my ($cfg, $filter);
       $cfg    =  $self->{auth}->{LDAP_config};
       $filter =  "$cfg->{filter}";
       $filter =~ s|^\s+||;
       $filter =~ s|\s+$||;
       $login  =~ s|\\|\\\\|g;
       $login  =~ s|\(|\\\(|g;
       $login  =~ s|\)|\\\)|g;
       $login  =~ s|\*|\\\*|g;
       $login  =~ s|\x00|\\00|g;
       if ($filter =~ m|<\%login\%>|) {
         substr($filter, $LAST_MATCH_START[0], $LAST_MATCH_END[0] - $LAST_MATCH_START[0]) = $login;
       } elsif ($filter) {
         if ((substr($filter, 0, 1) ne '(') || (substr($filter, -1, 1) ne ')')) {
           $filter = "($filter)";
+        }
         $filter = "(&${filter}($cfg->{attribute}=${login}))";
       } else {
         $filter = "$cfg->{attribute}=${login}";
+      }
       $main::lxdebug->leave_sub();
       return $filter;
+    }
     sub _get_user_dn {
       $main::lxdebug->enter_sub();
       my $self   = shift;
       my $ldap   = shift;
       my $login  = shift;
       $self->{dn_cache} ||= { };
       if ($self->{dn_cache}->{$login}) {
         $main::lxdebug->leave_sub();
         return $self->{dn_cache}->{$login};
+      }
       my $cfg    = $self->{auth}->{LDAP_config};
       my $filter = $self->_get_filter($login);
       my $mesg   = $ldap->search('base' => $cfg->{base_dn}, 'scope' => 'sub', 'filter' => $filter);
       if ($mesg->is_error() || (0 == $mesg->count())) {
         $main::lxdebug->leave_sub();
         return undef;
+      }
       my $entry                   = $mesg->entry(0);
       $self->{dn_cache}->{$login} = $entry->dn();
       $main::lxdebug->leave_sub();
       return $self->{dn_cache}->{$login};
+    }
     sub authenticate {
       $main::lxdebug->enter_sub();
       my $self       = shift;
       my $login      = shift;
       my $password   = shift;
       my $is_crypted = shift;
       if ($is_crypted) {
         $main::lxdebug->leave_sub();
         return SL::Auth::ERR_BACKEND;
+      }
       my $ldap = $self->_connect();
       if (!$ldap) {
         $main::lxdebug->leave_sub();
         return SL::Auth::ERR_BACKEND;
+      }
       my $dn = $self->_get_user_dn($ldap, $login);
       $main::lxdebug->message(LXDebug::DEBUG2, "LDAP authenticate: dn $dn");
       if (!$dn) {
         $main::lxdebug->leave_sub();
         return SL::Auth::ERR_BACKEND;
+      }
       my $mesg = $ldap->bind($dn, 'password' => $password);
       $main::lxdebug->message(LXDebug::DEBUG2, "LDAP authenticate: bind mesg " . $mesg->error());
       $main::lxdebug->leave_sub();
       return $mesg->is_error() ? SL::Auth::ERR_PASSWORD : SL::Auth::OK;
+    }
     sub can_change_password {
       return 0;
+    }
     sub change_password {
       return SL::Auth::ERR_BACKEND;
+    }
     sub verify_config {
       $main::lxdebug->enter_sub();
       my $self = shift;
       my $cfg  = $self->{auth}->{LDAP_config};
       if (!$cfg) {
         $form->error($locale->text('config/authentication.pl: Key "LDAP_config" is missing.'));
+      }
       if (!$cfg->{host} || !$cfg->{attribute} || !$cfg->{base_dn}) {
         $form->error($locale->text('config/authentication.pl: Missing parameters in "LDAP_config". Required parameters are "host", "attribute" and "base_dn".'));
+      }
       $main::lxdebug->leave_sub();
+    }
 ;

     );
     %db_encoding_to_charset = map { $_->{dbencoding}, $_->{charset} } @db_encodings;
     %charset_to_db_encoding = map { $_->{charset}, $_->{dbencoding} } @db_encodings;
     use constant DEFAULT_CHARSET => 'ISO-8859-15';
-...
       my $dbh = $form->dbconnect($myconfig);
       my (@filter_values, $filter);
       if ($form->{"partnumber"}) {
         $filter .= qq| AND (partnumber ILIKE ?)|;
         push(@filter_values, '%' . $form->{"partnumber"} . '%');
       foreach (qw(partnumber description)) {
         next unless $form->{$_};
         $filter .= qq| AND ($_ ILIKE ?)|;
         push @filter_values, '%' . $form->{$_} . '%';
+      }
       if ($form->{"description"}) {
         $filter .= qq| AND (description ILIKE ?)|;
         push(@filter_values, '%' . $form->{"description"} . '%');
       if ($form->{no_assemblies}) {
         $filter .= qq| AND (NOT COALESCE(assembly, 'f'))|;
+      }
       if ($form->{no_services}) {
         $filter .= qq| AND (COALESCE(inventory_accno_id, 0) > 0)|;
+      }
       substr($filter, 1, 3) = "WHERE" if ($filter);
       $order_by =~ s/[^a-zA-Z_]//g;

                  dump_query quote_db_date
                  selectfirst_hashref_query selectfirst_array_query
                  selectall_hashref_query selectall_array_query
                  selectall_as_map
                  prepare_execute_query prepare_query);
     sub conv_i {
-...
       return @ret;
+    }
     sub selectall_as_map {
       $main::lxdebug->enter_sub(2);
       my ($form, $dbh, $query, $key_col, $value_col) = splice(@_, 0, 5);
       my $sth = prepare_execute_query($form, $dbh, $query, @_);
       my %hash;
       if ('' eq ref $value_col) {
         while (my $ref = $sth->fetchrow_hashref()) {
           $hash{$ref->{$key_col}} = $ref->{$value_col};
+        }
       } else {
         while (my $ref = $sth->fetchrow_hashref()) {
           $hash{$ref->{$key_col}} = { map { $_ => $ref->{$_} } @{ $value_col } };
+        }
+      }
       $sth->finish();
       $main::lxdebug->leave_sub(2);
       return %hash;
+    }
 ;
-...
     Prepares and executes a query using DBUtils functions, retireves all data from the database, and returns it in hashref mode. This is slightly confusing, as the data structure will actually be a reference to an array, containing hashrefs for each row.

... Dieser Diff wurde abgeschnitten, weil er die maximale Anzahl anzuzeigender Zeilen überschreitet.

Auch abrufbar als: Unified diff

Projekt

Allgemein

Profil

projekt kivitendo

Revision 8c7e4493

Von Moritz Bunkus vor fast 17 Jahren hinzugefügt