projekt kivitendo

  $self->generate_datev_data(from_to => $self->fromto);

  return if $self->errors;

  my $datev_ref = SL::DATEV::CSV->new(datev_lines  => $self->generate_datev_lines,

                                      from         => $self->from,

                                      to           => $self->to,

                                      locked       => $self->locked,

                                     );

  my $filename = "EXTF_DATEV_kivitendo" . $self->from->ymd() . '-' . $self->to->ymd() . ".csv";

  my $csv = Text::CSV_XS->new({

              binary       => 1,

              sep_char     => ";",

              always_quote => 1,

              eol          => "\r\n",

            }) or die "Cannot use CSV: ".Text::CSV_XS->error_diag();

  my $csv_file = IO::File->new($self->export_path . '/' . $filename, '>:encoding(cp1252)') or die "Can't open: $!";

  $csv->print($csv_file, $_) for @{ $datev_ref };

  $csv_file->close;

  return { download_token => $self->download_token, filenames => $filename };

sub locked {

 my $self = shift;

 if (@_) {

   $self->{locked} = $_[0];

 }

 return $self->{locked};

}

=item locked

Boolean if the transactions are locked (read-only in kivitenod) or not.

Default value is false

use SL::Helper::DateTime;

sub new {

  my $class = shift;

  my %data  = @_;

  my $obj = bless {}, $class;

  croak(t8('We need a valid from date'))      unless (ref $data{from} eq 'DateTime');

  croak(t8('We need a valid to date'))        unless (ref $data{to}   eq 'DateTime');

  croak(t8('We need a array of datev_lines')) unless (ref $data{datev_lines} eq 'ARRAY');

  # TODO no params here, better class variables/values

  return _csv_buchungsexport(from        => $data{from},

                             to          => $data{to},

                             datev_lines => $data{datev_lines},

                             locked      => $data{locked},

                            );

  $obj;

}

sub _kivitendo_to_datev {

sub _generate_csv_header {

  my %params  = @_;

  croak "Wrong format for from $params{from}" unless $params{from} =~ m/^[0-9]{8}$/;

  croak "Wrong format for to $params{to}"   unless $params{to} =~ m/^[0-9]{8}$/;

  # croak "Wrong state of locking"      unless $params{locked} =~ m/^(0|1)$/;

  my $locked = defined($params{locked}) ? 1 : 0;

    $params{from}, $params{to}, "", "", 1, "", $locked,

sub _csv_buchungsexport {

  my %params = @_;

  my @csv_columns = _kivitendo_to_datev();

  my @csv_headers = _generate_csv_header(

                      from                     => $params{from}->ymd(''),

                      to                       => $params{to}->ymd(''),

                      first_day_of_fiscal_year => $params{to}->year . '0101',

                      locked                   => $params{locked}

                    );

  my @array_of_datev;

  # 2 Headers

  push @array_of_datev, \@csv_headers;

  push @array_of_datev, [ map { $_->{csv_header_name} } @csv_columns ];

  my @warnings;

  foreach my $row (@{ $params{datev_lines} }) {

    my @current_datev_row;

    # shorten strings

    if ($row->{belegfeld1}) {

      $row->{buchungsbes} = $row->{belegfeld1} if $row->{belegfeld1};

      $row->{belegfeld1}  = substr($row->{belegfeld1}, 0, 12);

      $row->{buchungsbes} = substr($row->{buchungsbes}, 0, 60);

    }

    $row->{datum} = DateTime->from_kivitendo($row->{datum})->strftime('%d%m');

    $row->{kost1}       = substr($row->{kost1}, 0, 8) if $row->{kost1};

    $row->{kost2}       = substr($row->{kost2}, 0, 8) if $row->{kost2};

    # , as decimal point and trim for UstID

    $row->{umsatz}      = _format_amount($row->{umsatz});

    $row->{ustid}       =~ s/\s//g if $row->{ustid}; # trim whitespace

    foreach my $column (@csv_columns) {

      if (exists $column->{max_length} && $column->{kivi_datev_name} ne 'not yet implemented') {

        # check max length

        die "Incorrect length of field" if length($row->{ $column->{kivi_datev_name} }) > $column->{max_length};

      }

      if (exists $column->{valid_check} && $column->{kivi_datev_name} ne 'not yet implemented') {

        # more checks, listed as user warnings

        push @warnings, t8("Wrong field value '#1' for field '#2' for the transaction" .

                            " with amount '#3'",$row->{ $column->{kivi_datev_name} },

                            $column->{kivi_datev_name},$row->{umsatz})

          unless ($column->{valid_check}->($row->{ $column->{kivi_datev_name} }));

      }

      push @current_datev_row, $row->{ $column->{kivi_datev_name} };

    }

    push @array_of_datev, \@current_datev_row;

  }

  return (\@array_of_datev, \@warnings);

}

  use SL::DATEV qw(:CONSTANTS);

  use SL::DATEV::CSV;

  my $startdate = DateTime->new(year => 2014, month => 9, day => 1);

  my $enddate   = DateTime->new(year => 2014, month => 9, day => 31);

  my $datev = SL::DATEV->new(

    exporttype => DATEV_ET_BUCHUNGEN,

    format     => DATEV_FORMAT_CSV,

    from       => $startdate,

    to         => $enddate,

  );

  $datev->generate_datev_data;

  my $datev_ref = SL::DATEV::CSV->new(datev_lines  => $datev->generate_datev_lines,

                                      from         => $datev->from,

                                      to           => $datev->to,

                                      locked       => $datev->locked,

                                     );

=head1 DESCRIPTION

=item new PARAMS

Constructor for CSV-DATEV export.

Checks mandantory params as described in section synopsis.

Furthermore C<params{locked}> is a perlish boolean.

=item _csv_buchungsexport

Generates the CSV-Format data for the CSV DATEV export and returns

an 2-dimensional array as an array_ref.

May additionally return a second array_ref with warnings.

Requires the same date fields as the constructor for a valid DATEV header.

Furthermore we assume that the first day of the fiscal year is

the first of January and we cannot guarantee that our data in kivitendo

is locked, that means a booking cannot be modified after a defined (vat tax)

period.

Some validity checks (max_length and regex) will be done if the

data structure contains them and the field is defined.

To add or alter the structure of the data take a look at the C<@kivitendo_to_datev> structure.

my ($datev_ref, $warnings_ref) = SL::DATEV::CSV->new(datev_lines  => $datev1->generate_datev_lines,

                                                     from         => $startdate,

                                                     to           => $enddate,

                                                     locked       => $datev1->locked,

                                                    );

my @warnings = $warnings_ref;

my ($datev_ref2, $warnings_ref2) = SL::DATEV::CSV->new(datev_lines  => $datev3->generate_datev_lines,

                                                       from         => $startdate,

                                                       to           => $enddate,

                                                       locked       => $datev3->locked,

                                                      );

@warnings = $warnings_ref2;

my ($datev_ref3, $warnings_ref3) = SL::DATEV::CSV->new(datev_lines  => $datev2->generate_datev_lines,

                                                       from         => $startdate,

                                                       to           => $enddate,

                                                       locked       => $datev2->locked,

                                                      );

my @data_csv = splice @{ $datev_ref3 }, 2, 5;

@data_csv    = sort { $a->[0] cmp $b->[0] } @data_csv;

'buchungstext' => 'Testcustomer',

# reset use_pk for csv_buchungsexport

$datev1->use_pk(0);

$datev1->generate_datev_data;

my ($datev_ref, $w_ref) = SL::DATEV::CSV->new(datev_lines  => $datev1->generate_datev_lines,

                                              from         => $startdate,

                                              to           => $enddate,

                                              locked       => $datev1->locked,

                                   );

# warnings should be undef -> no array elements at all

is(scalar @{ $w_ref }, 0);

my @data_csv = splice @{ $datev_ref }, 2, 5;