projekt kivitendo

#use SL::Auth;

use SL::DBUtils;

sub new {

  $main::lxdebug->enter_sub();

  if (!$dbh) {

    $main::lxdebug->leave_sub();

  }

  my $query             = qq|SELECT password FROM auth."user" WHERE login = ?|;

  $main::lxdebug->leave_sub();

}

sub can_change_password {

  if (!$dbh) {

    $main::lxdebug->leave_sub();

  }

  $password = crypt $password, substr($login, 0, 2) if (!$is_crypted);

#use SL::Auth;

sub new {

  $main::lxdebug->enter_sub();

  if ($is_crypted) {

    $main::lxdebug->leave_sub();

  }

  my $ldap = $self->_connect();

  if (!$ldap) {

    $main::lxdebug->leave_sub();

  }

  my $dn = $self->_get_user_dn($ldap, $login);

  if (!$dn) {

    $main::lxdebug->leave_sub();

  }

  my $mesg = $ldap->bind($dn, 'password' => $password);

  $main::lxdebug->leave_sub();

}

sub can_change_password {

}

sub change_password {

}

sub verify_config {

  $main::lxdebug->enter_sub();

  my $self = shift;

  my $cfg  = $self->{auth}->{LDAP_config};

use SL::FU;

use SL::Notes;

sub get_tuple {

  $main::lxdebug->enter_sub();

use File::Path;

use Time::HiRes qw(gettimeofday);

sub _get_export_path {

  $main::lxdebug->enter_sub();

  # connect to database

  my $dbh = $form->dbconnect($myconfig);

  $sth->execute || $form->dberror($query);

  map { $form->{$_} = $ref->{$_} } keys %$ref;

  # connect to database

  my $dbh = $form->dbconnect_noauto($myconfig);

  $dbh->do($query) || $form->dberror($query);

  $query = qq|INSERT INTO datev

    . $dbh->quote($form->{mandantennr}) . qq|,|

    . $dbh->quote($form->{datentraegernr}) . qq|,|

    . $dbh->quote($form->{abrechnungsnr}) . qq|)|;

  $sth->execute || $form->dberror($query);

  $sth->finish;

  $main::lxdebug->enter_sub();

  my ($zeitraum, $monat, $quartal, $transdatefrom, $transdateto) = @_;

  $fromto = "transdate >= ";

  my $dbh      =  $form->get_standard_dbh($myconfig);

  my @errors   = ();

  $fromto      =~ s/transdate/ac\.transdate/g;

  my $sth = prepare_execute_query($form, $dbh, $query);

  my $counter = 0;

    $counter++;

    if (($counter % 500) == 0) {

      print("$counter ");

    my $firstrun = 1;

    while (abs($count) > 0.01 || $firstrun) {

      last unless ($ref2);

      if ($ref2->{trans_id} != $trans->[0]->{trans_id}) {

    my $idx        = 0;

    my $correction = 0;

    while (abs($absumsatz) >= 0.01) {

      if ($idx >= scalar @taxed) {

        last if (!$correction);

  $main::lxdebug->enter_sub();

  my ($myconfig, $form, $fromto, $start_jahr) = @_;

  my $jahr = $start_jahr;

  if (!$jahr) {

  my ($date, $six) = @_;

  if ($day =~ /^0/) {

    $day = substr($day, 1, 1);

  if ($fromto ne "") {

    $versionset .= "0000" . substr($header, 28, 19);

  } else {

    $versionset .= $datum . "001" . substr($header, 28, 4);

  }

  my $export_path = _get_export_path() . "/";

  my $filename    = "ED00000";

  my $evfile      = "EV01";

  my $fileno = 0;

  $form->header;

  Buchungssätze verarbeitet:

|;

    &get_dates($form->{zeitraum}, $form->{monat},

               $form->{quartal},  $form->{transdatefrom},

               $form->{transdateto});

    $filename++;

    my $ed_filename = $export_path . $filename;

    push(@filenames, $filename);

    my $kne_file = SL::DATEV::KNEFile->new();

    $kne_file->add_block($header);

    while (scalar(@{ $form->{DATEV} }) > 0) {

      $counter++;

      if (($counter % 500) == 0) {

        print("$counter ");

      my $datevautomatik = 0;

      my $taxkey         = 0;

      my $charttax       = 0;

      my $iconv          = $main::locale->{iconv_iso8859};

      my %umlaute = ($iconv->convert('?') => 'ae',

                     $iconv->convert('?') => 'oe',

      }

      # Umwandlung von Umlauten und Sonderzeichen in erlaubte Zeichen bei Textfeldern

        $transaction->[$haben]->{'invnumber'} =~ s/${umlaut}/${umlaute{$umlaut}}/g;

        $transaction->[$haben]->{'name'}      =~ s/${umlaut}/${umlaute{$umlaut}}/g;

      }

  }

  #Make EV Verwaltungsdatei

  push(@filenames, $evfile);

  open(EV, "> $ev_filename") or die "can't open outputfile: EV01\n";

  print(EV $ev_header);

    print(EV $ed_versionset[$file]);

  }

  close(EV);

  my $export_path = _get_export_path() . "/";

  my $filename    = "ED00000";

  my $evfile      = "EV01";

  my $fileno          = 1;

  my $i               = 0;

  my $blockcount      = 1;

  my $ed_filename = $export_path . $filename;

  push(@filenames, $filename);

  open(ED, "> $ed_filename") or die "can't open outputfile: $!\n";

  $remaining_bytes -= length($header);

  # connect to database

  my $dbh = $form->dbconnect($myconfig);

  my $sth = $dbh->prepare($query);

  $sth->execute(@values) || $form->dberror($query);

    if (($remaining_bytes - length("t" . $ref->{'accno'})) <= 6) {

      $fuellzeichen = ($blockcount * 256 - length($buchungssatz . $header));

      $buchungssatz .= "\x00" x $fuellzeichen;

  print(ED $header);

  print(ED $buchungssatz);

  $fuellzeichen = 256 - (length($header . $buchungssatz . "z") % 256);

  print(ED "z");

  print(ED $dateiende);

  close(ED);

  $ed_versionset[0] =

    &make_ed_versionset($header, $filename, $blockcount, $fromto);

  push(@filenames, $evfile);

  open(EV, "> $ev_filename") or die "can't open outputfile: EV01\n";

  print(EV $ev_header);

    print(EV $ed_versionset[$file]);

  }

  close(EV);

package SL::DATEV::KNEFile;

sub new {

  my $type = shift;

  my $self = {};

  my $self   = shift;

  my $amount = shift;

  my $width  = shift;

  $amount =~ s/-//;

  my ($places, $decimal_places) = split m/\./, "$amount";

use SL::DBUtils;

use SL::Notes;

sub save {

  $main::lxdebug->enter_sub();

package Form;

use Data::Dumper;

use CGI;

use List::Util qw(first max min sum);

use List::MoreUtils qw(any);

my $standard_dbh;

END {

      _recode_recursively($iconv, $self);

    }

  }

  $self->{action}  =  lc $self->{action};

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

  if ($standard_dbh && !$standard_dbh->{Active}) {

    undef $standard_dbh;

  }

use vars qw(%converters);

sub get_converter {

  my ($from_charset, $to_charset) = @_;

package SL::MIME;

sub mime_type_from_ext {

  $main::lxdebug->enter_sub();

use SL::MIME;

use SL::Template;

my $num_sent = 0;

sub new {

#

#=====================================================================

sub init {

  my $self = shift;

    # add thousand, million

    if ($i) {

      push(@textnumber, $self->{numbername}{$num});

    }

use SL::DBUtils;

use SL::IC;

=head1 NAME

OE.pm - Order entry module

use SL::DBUtils;

sub overpayment {

  $main::lxdebug->enter_sub();

  do_query($form, $dbh, $query, @values);

  # add AR/AP

  $query =

    qq|INSERT INTO acc_trans (trans_id, chart_id, transdate, amount) | .

use SL::DBUtils;

use Data::Dumper;

use List::Util qw(sum);

# new implementation of balance sheet

# readme!

  my $glwhere  = "";

  my $prwhere  = "";

  my $subwhere = "";

  my $item;

  if ($fromdate) {

  my $glwhere       = '';

  my $glsumwhere    = '';

  my $tofrom;

  if ($form->{fromdate} || $form->{todate}) {

    if ($form->{fromdate}) {

# Web http://www.lx-office.org

#

#====================================================================

package SimpleTemplate;

# Parameters:

#   1. The template's file name

#   2. A reference to the Form object

@ISA = qw(SimpleTemplate);

sub new {

  my $type = shift;

@ISA = qw(LaTeXTemplate);

sub new {

  my $type = shift;

@ISA = qw(LaTeXTemplate);

sub new {

  my $type = shift;

@ISA = qw(SimpleTemplate);

sub new {

  my $type = shift;

  foreach my $module (qw(Archive::Zip Text::Iconv)) {

    eval("use ${module};");

  }

  my $zip = Archive::Zip->new();

    $self->{"error"} = "File not found/is not a OpenDocument file.";

    $main::lxdebug->leave_sub();

    return 0;

  my $dfname = $self->{"userspath"} . "/xvfb_display";

  my $display;

  if ((-f $dfname) && open(IN, $dfname)) {

    my $pid = <IN>;

    chomp($pid);

    chomp($xauthority);

    close(IN);

    if ((! -d "/proc/$pid") || !open(IN, "/proc/$pid/cmdline")) {

      unlink($dfname, $xauthority);

      $main::lxdebug->leave_sub();

      return undef;

    my $line = <IN>;

    close(IN);

    if ($line !~ /xvfb/i) {

      unlink($dfname, $xauthority);

      $main::lxdebug->leave_sub();

      return undef;

    $ENV{"XAUTHORITY"} = $xauthority;

    $ENV{"DISPLAY"} = $display;

  } else {

  }

  $main::lxdebug->leave_sub();

  my ($self) = @_;

  my $display = $self->is_xvfb_running();

    $display++;

  }

  $display = ":${display}";

  my $mcookie = `mcookie`;

  die("Installation error: mcookie not found.") if ($? != 0);

  chomp($mcookie);

  my $xauthority = "/tmp/.Xauthority-" . $$ . "-" . time() . "-" . int(rand(9999999));

  $ENV{"XAUTHORITY"} = $xauthority;

  system("xauth add \"${display}\" . \"${mcookie}\"");

  if ($? != 0) {

    return undef;

  }

  my $pid = fork();

  if (0 == $pid) {

    exec($main::xvfb_bin, $display, "-screen", "0", "640x480x8", "-nolisten", "tcp");

  }

  sleep(3);

  local *OUT;

  my $dfname = $self->{"userspath"} . "/xvfb_display";

  print(OUT "$pid\n$display\n$xauthority\n");

  close(OUT);

  if (!$self->is_xvfb_running()) {

    $self->{"error"} = "Conversion to PDF failed because OpenOffice could not be started.";

    return undef;

  }

  $main::lxdebug->leave_sub();

  system("./scripts/oo-uno-test-conn.py $main::openofficeorg_daemon_port " .

         "> /dev/null 2> /dev/null");

  my $res = $? == 0;

  $main::lxdebug->leave_sub();

  my ($self) = @_;

  my ($try, $spawned_oo, $res);

    if (!$spawned_oo) {

      my $pid = fork();

      if (0 == $pid) {

        chdir('/');

        open(STDIN, '/dev/null');

        open(STDOUT, '>/dev/null');

        my $new_pid = fork();

        exit if ($new_pid);

        my $ssres = setsid();

        my @cmdline = ($main::openofficeorg_writer_bin,

                       "-minimized", "-norestore", "-nologo", "-nolockcheck",

                       "-headless",

        exec(@cmdline);

      }

      $spawned_oo = 1;

      sleep(3);

    }

}

sub get_mime_type() {

  if ($self->{"form"}->{"format"} =~ /pdf/) {

    return "application/pdf";

  } else {

@ISA = qw(HTMLTemplate);

sub new {

  #evtl auskommentieren

  my $type = shift;

use base qw( Template::Plugin );

use Template::Plugin;

sub new {

  my $class   = shift;

  my $context = shift;

use SL::AM;

sub new {

  my $class   = shift;

  my $context = shift;

package SL::Template::Plugin::MultiColumnIterator;

use base 'Template::Plugin';

use Template::Constants;

use Template::Exception;

use SL::LXDebug;

use Data::Dumper;

our $AUTOLOAD;

sub new {

    my $class   = shift;

    my $context = shift;

    my $data    = shift || [ ];

        $data  = [ $data ] ;

    }

    bless {

        _DATA  => $data,

sub get_first {

    my $self  = shift;

    my $data  = $self->{ _DATA };

    my $dim   = $self->{ _DIM  };

    $self->{ _DATASET } = $self->{ _DATA };

    my $size = int ((scalar @$data - 1) / $dim) + 1;

    my $index = 0;

    return (undef, Template::Constants::STATUS_DONE) unless $size;

    # initialise various counters, flags, etc.

    @$self{ qw( PREV ) } = ( undef );

    $$self{ qw( NEXT ) } = [ @{ $self->{ _DATASET }  }[ map { $index + 1 + $_ * $size } 0 .. ($dim - 1) ] ];

    return [ @{ $self->{ _DATASET } }[ map { $index + $_ * $size } 0 .. ($dim - 1) ] ];

}

sub get_next {

    my $self = shift;

    my ($max, $index) = @$self{ qw( MAX INDEX ) };

    my $data = $self->{ _DATASET };

        @$self{ qw( INDEX COUNT FIRST LAST ) } = ( $index, $index + 1, 0, $index == $max ? 1 : 0 );

        $$self{ qw( PREV ) } = [ @{ $self->{ _DATASET } }[ map { $index - 1 + $_ * $size } 0 .. ($dim - 1) ] ];

        $$self{ qw( NEXT ) } = [ @{ $self->{ _DATASET } }[ map { $index + 1 + $_ * $size } 0 .. ($dim - 1) ] ];

        return [ @{ $self->{ _DATASET } }[ map { $index + $_ * $size } 0 .. ($dim - 1) ] ];

    }

    else {

        return (undef, Template::Constants::STATUS_DONE);   ## RETURN ##

    }

}

}

sub dump {

    my $self = shift;

    return join('',

         "<pre>",

         "  Data: ", Dumper($self->{ _DATA  }), "\n",

}

sub index {

  my ($self) = @_;

  return $self->{ INDEX };

}

sub number {

  my ($self) = @_;

  return $self->{ NUMBER };

}

sub count {

  my ($self) = @_;

  return $self->{ COUNT };

}

sub max {

  my ($self) = @_;

  return $self->{ MAX };

}

sub size {

  my ($self) = @_;

  return $self->{ SIZE };

}

sub first {

  my ($self) = @_;

  return $self->{ FIRST };

}

sub last {

  my ($self) = @_;

  return $self->{ LAST};

}

use SL::AM;

use SL::DBUtils;

use SL::Form;

use warnings;

sub transfer {

  $main::lxdebug->enter_sub();

  my $dbh = $form->get_standard_dbh($myconfig);

  # filters

  if ($filter{warehouse_id} ne '') {

    push @filter_ary, "w1.id = ? OR w2.id = ?";

  }

  my @contents = ();

    map { /^r_/; $ref->{"$'"} = $ref->{$_} } keys %$ref;

    my $qty = $ref->{"qty"} * 1;

  my (%non_empty_bins, @all_fields, @contents);

    $ref->{qty} *= 1;

    my $qty      = $ref->{qty};