projekt kivitendo

sub new {

  my ($type, %params) = @_;

  my $self            = bless {}, $type;

  $self->_read_auth_config(%params);

  $self->reset;

  return $self;

}

}

sub _read_auth_config {

  my ($self, %params) = @_;

  map { $self->{$_} = $::lx_office_conf{authentication}->{$_} } keys %{ $::lx_office_conf{authentication} };

  $self->{session_timeout} *= 1;

  $self->{session_timeout}  = 8 * 60 if (!$self->{session_timeout});

}

sub has_access_to_client {

}

sub authenticate_root {

  my ($self, $password) = @_;

  my $session_root_auth = $self->get_session_value(SESSION_KEY_ROOT_AUTH());

  if (defined $session_root_auth && $session_root_auth == OK) {

    return OK;

  }

  if (!defined $password) {

    return ERR_PASSWORD;

  }

  my $result = $password eq $admin_password ? OK : ERR_PASSWORD;

  $self->set_session_value(SESSION_KEY_ROOT_AUTH() => $result);

  return $result;

}

sub authenticate {

  my ($self, $login, $password) = @_;

  if (!$self->client || !$self->has_access_to_client($login)) {

    return ERR_PASSWORD;

  }

  my $session_auth = $self->get_session_value(SESSION_KEY_USER_AUTH());

  if (defined $session_auth && $session_auth == OK) {

    return OK;

  }

  if (!defined $password) {

    return ERR_PASSWORD;

  }

  my $result = $login ? $self->{authenticator}->authenticate($login, $password) : ERR_USER;

  $self->set_session_value(SESSION_KEY_USER_AUTH() => $result, login => $login, client_id => $self->client->{id});

  return $result;

}

}

sub dbconnect {

  my $self     = shift;

  my $may_fail = shift;

  if ($self->{dbh}) {

    return $self->{dbh};

  }

    $main::form->error($main::locale->text('The connection to the authentication database failed:') . "\n" . $DBI::errstr);

  }

  return $self->{dbh};

}

sub dbdisconnect {

  my $self = shift;

  if ($self->{dbh}) {

    $self->{dbh}->disconnect();

    delete $self->{dbh};

  }

}

sub check_tables {

  my ($self, $dbh)    = @_;

  $dbh   ||= $self->dbconnect();

  my ($count) = $dbh->selectrow_array($query);

  return $count > 0;

}

sub check_database {

  my $self = shift;

  my $dbh  = $self->dbconnect(1);

  return $dbh ? 1 : 0;

}

sub create_database {

  my $self   = shift;

  my %params = @_;

  }

  $dbh->disconnect();

}

sub create_tables {

  my $self = shift;

  my $dbh  = $self->dbconnect();

  $dbh->rollback();

  SL::DBUpgrade2->new(form => $::form)->process_query($dbh, 'sql/auth_db.sql');

}

sub save_user {

  my $self   = shift;

  my $login  = shift;

  my %params = @_;

  }

  $dbh->commit();

}

sub can_change_password {

}

sub change_password {

  my ($self, $login, $new_password) = @_;

  my $result = $self->{authenticator}->change_password($login, $new_password);

  return $result;

}

sub read_all_users {

  my $self  = shift;

  my $dbh   = $self->dbconnect();

  $sth->finish();

  return %users;

}

sub read_user {

  my ($self, %params) = @_;

  my $dbh   = $self->dbconnect();

  $sth->finish();

  return %user_data;

}

sub get_user_id {

  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);

  return $id;

}

sub delete_user {

  my $self  = shift;

  my $login = shift;

  my $dbh   = $self->dbconnect;

  my $id    = $self->get_user_id($login);

  $dbh->begin_work;

  # do_query($::form, $u_dbh, qq|UPDATE employee SET deleted = 't' WHERE login = ?|, $login) if $u_dbh && $user_db_exists;

  $dbh->commit;

}

# --------------------------------------

my $session_id;

sub restore_session {

  my $self = shift;

  $session_id        =  $::request->{cgi}->cookie($self->get_session_cookie_name());

  $self->{SESSION}   = { };

  if (!$session_id) {

    return $self->session_restore_result(SESSION_NONE());

  }

  # Don't fail if the auth DB doesn't yet.

  if (!( $dbh = $self->dbconnect(1) )) {

    return $self->session_restore_result(SESSION_NONE());

  }

  if (!($sth = $dbh->prepare($query)) || !$sth->execute($session_id)) {

    $sth->finish if $sth;

    return $self->session_restore_result(SESSION_NONE());

  }

  $cookie_is_bad     ||= $cookie->{ip_address} ne $ENV{REMOTE_ADDR}                       if !$api_token_cookie;

  if ($cookie_is_bad) {

    $self->destroy_session();

    return $self->session_restore_result($cookie ? SESSION_EXPIRED() : SESSION_NONE());

  }

    $self->_load_without_auto_restore_column($dbh, $session_id);

  }

  return $self->session_restore_result(SESSION_OK());

}

}

sub destroy_session {

  my $self = shift;

  if ($session_id) {

    $session_id      = undef;

    $self->{SESSION} = { };

  }

}

sub active_session_ids {

}

sub expire_sessions {

  my $self  = shift;

  my $dbh   = $self->dbconnect();

    $dbh->commit();

  }

}

sub _create_session_id {

  my @data;

  map { push @data, int(rand() * 255); } (1..32);

  my $id = md5_hex(pack 'C*', @data);

  return $id;

}

}

sub save_session {

  my $self         = shift;

  my $provided_dbh = shift;

  my $dbh          = $provided_dbh || $self->dbconnect(1);

  $dbh->begin_work unless $provided_dbh;

  # the admin is just trying to create the auth database.

  if (!$dbh->do(qq|LOCK auth.session_content|)) {

    $dbh->rollback unless $provided_dbh;

    return;

  }

  }

  $dbh->commit() unless $provided_dbh;

}

sub set_session_value {

  my $self   = shift;

  my @params = @_;

    }

  }

  return $self;

}

sub delete_session_value {

  my $self = shift;

  $self->{SESSION} ||= { };

  delete @{ $self->{SESSION} }{ @_ };

  return $self;

}

sub get_session_value {

  my $self = shift;

  my $data = $self->{SESSION} && $self->{SESSION}->{ $_[0] } ? $self->{SESSION}->{ $_[0] }->get : undef;

  return $data;

}

}

sub session_tables_present {

  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}) {

    return $self->{session_tables_present};

  }

  my $dbh  = $self->dbconnect(1);

  if (!$dbh) {

    return 0;

  }

  $self->{session_tables_present} = 2 == $count;

  return $self->{session_tables_present};

}

}

sub read_groups {

  my $self = shift;

  my $form   = $main::form;

  }

  $sth->finish();

  return $groups;

}

sub save_group {

  my $self  = shift;

  my $group = shift;

  $sth->finish();

  $dbh->commit();

}

sub delete_group {

  my $self = shift;

  my $id   = shift;

  do_query($form, $dbh, qq|DELETE FROM auth."group" WHERE id = ?|, $id);

  $dbh->commit();

}

sub evaluate_rights_ary {

  my $ary    = shift;

  my $value  = 0;

    }

  }

  return $value;

}

sub _parse_rights_string {

  my $self   = shift;

  my $login  = shift;

      pop @stack;

      if (!@stack) {

        return 0;

      }

  my $result = ($access || (1 < scalar @stack)) ? 0 : evaluate_rights_ary($stack[0]);

  return $result;

}

sub check_right {

  my $self    = shift;

  my $login   = shift;

  my $right   = shift;

  my $granted = $self->{FULL_RIGHTS}->{$login}->{$right};

  $granted    = $default if (!defined $granted);

  return $granted;

}

sub assert {

  my ($self, $right, $dont_abort) = @_;

  if ($self->check_right($::myconfig{login}, $right)) {

    return 1;

  }

    $::form->show_generic_error($::locale->text("You do not have the permissions to access this function."));

  }

  return 0;

}

sub load_rights_for_user {

  my ($self, $login) = @_;

  my $dbh   = $self->dbconnect;

  my ($query, $sth, $row, $rights);

  }

  $sth->finish();

  return $rights;

}