SL/GoBD.pm

   1 package SL::GoBD;
   2
   3 # TODO:
   4 # optional: background jobable
   5
   6 use strict;
   7 use utf8;
   8
   9 use parent qw(Rose::Object);
  10
  11 use Text::CSV_XS;
  12 use XML::Writer;
  13 use Archive::Zip;
  14 use File::Temp ();
  15 use File::Spec ();
  16 use List::MoreUtils qw(any);
  17 use List::UtilsBy qw(partition_by sort_by);
  18
  19 use SL::DB::Helper::ALL; # since we work on meta data, we need everything
  20 use SL::DB::Helper::Mappings;
  21 use SL::Locale::String qw(t8);
  22
  23 use Rose::Object::MakeMethods::Generic (
  24   scalar                  => [ qw(from to writer company location) ],
  25   'scalar --get_set_init' => [ qw(files tempfiles export_ids tables csv_headers) ],
  26 );
  27
  28 # in this we find:
  29 # key:         table name
  30 # name:        short name, translated
  31 # description: long description, translated
  32 # columns:     list of columns to export. export all columns if not present
  33 # primary_key: override primary key
  34 my %known_tables = (
  35   chart    => { name => t8('Charts'),    description => t8('Chart of Accounts'),    primary_key => 'accno', columns => [ qw(id accno description) ],     },
  36   customer => { name => t8('Customers'), description => t8('Customer Master Data'), columns => [ qw(id customernumber name department_1 department_2 street zipcode city country contact phone fax email notes taxnumber obsolete ustid) ] },
  37   vendor   => { name => t8('Vendors'),   description => t8('Vendor Master Data'),   columns => [ qw(id vendornumber name department_1 department_2 street zipcode city country contact phone fax email notes taxnumber obsolete ustid) ] },
  38 );
  39
  40 my %column_titles = (
  41    chart => {
  42      id             => t8('ID'),
  43      accno          => t8('Account Number'),
  44      description    => t8('Description'),
  45    },
  46    customer_vendor => {
  47      id             => t8('ID (lit)'),
  48      name           => t8('Name'),
  49      department_1   => t8('Department 1'),
  50      department_2   => t8('Department 2'),
  51      street         => t8('Street'),
  52      zipcode        => t8('Zipcode'),
  53      city           => t8('City'),
  54      country        => t8('Country'),
  55      contact        => t8('Contact'),
  56      phone          => t8('Phone'),
  57      fax            => t8('Fax'),
  58      email          => t8('E-mail'),
  59      notes          => t8('Notes'),
  60      customernumber => t8('Customer Number'),
  61      vendornumber   => t8('Vendor Number'),
  62      taxnumber      => t8('Tax Number'),
  63      obsolete       => t8('Obsolete'),
  64      ustid          => t8('Tax ID number'),
  65    },
  66 );
  67 $column_titles{$_} = $column_titles{customer_vendor} for qw(customer vendor);
  68
  69 my %datev_column_defs = (
  70   trans_id          => { type => 'Rose::DB::Object::Metadata::Column::Integer', text => t8('ID'), },
  71   amount            => { type => 'Rose::DB::Object::Metadata::Column::Numeric', text => t8('Amount'), },
  72   credit_accname    => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Credit Account Name'), },
  73   credit_accno      => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Credit Account'), },
  74   credit_amount     => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Credit Amount'), },
  75   credit_tax        => { type => 'Rose::DB::Object::Metadata::Column::Numeric', text => t8('Credit Tax (lit)'), },
  76   debit_accname     => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Debit Account Name'), },
  77   debit_accno       => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Debit Account'), },
  78   debit_amount      => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Debit Amount'), },
  79   debit_tax         => { type => 'Rose::DB::Object::Metadata::Column::Numeric', text => t8('Debit Tax (lit)'), },
  80   invnumber         => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Reference'), },
  81   name              => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Name'), },
  82   notes             => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Notes'), },
  83   tax               => { type => 'Rose::DB::Object::Metadata::Column::Numeric', text => t8('Tax'), },
  84   taxdescription    => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('tax_taxdescription'), },
  85   taxkey            => { type => 'Rose::DB::Object::Metadata::Column::Integer', text => t8('Taxkey'), },
  86   tax_accname       => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Tax Account Name'), },
  87   tax_accno         => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Tax Account'), },
  88   transdate         => { type => 'Rose::DB::Object::Metadata::Column::Date',    text => t8('Transdate'), },
  89   vcnumber          => { type => 'Rose::DB::Object::Metadata::Column::Text',    text => t8('Customer/Vendor Number'), },
  90   customer_id       => { type => 'Rose::DB::Object::Metadata::Column::Integer', text => t8('Customer (database ID)'), },
  91   vendor_id         => { type => 'Rose::DB::Object::Metadata::Column::Integer', text => t8('Vendor (database ID)'), },
  92   itime             => { type => 'Rose::DB::Object::Metadata::Column::Date',    text => t8('Create Date'), },
  93   gldate            => { type => 'Rose::DB::Object::Metadata::Column::Date',    text => t8('Gldate'), },
  94 );
  95
  96 my @datev_columns = qw(
  97   trans_id
  98   customer_id vendor_id
  99   name           vcnumber
 100   transdate    invnumber      amount
 101   debit_accno  debit_accname debit_amount debit_tax
 102   credit_accno credit_accname credit_amount credit_tax
 103   taxdescription tax
 104   tax_accno    tax_accname    taxkey
 105   notes itime gldate
 106 );
 107
 108 # rows in this listing are tiers.
 109 # tables may depend on ids in a tier above them
 110 my @export_table_order = qw(
 111   ar ap gl oe delivery_orders
 112   invoice orderitems delivery_order_items
 113   customer vendor
 114   parts
 115   acc_trans
 116   chart
 117 );
 118
 119 # needed because the standard dbh sets datestyle german and we don't want to mess with that
 120 my $date_format = 'DD.MM.YYYY';
 121 my $number_format = '1000.00';
 122
 123 my $myconfig = { numberformat => $number_format };
 124
 125 # callbacks that produce the xml spec for these column types
 126 my %column_types = (
 127   'Rose::DB::Object::Metadata::Column::Integer'   => sub { $_[0]->tag('Numeric') },  # see Caveats for integer issues
 128   'Rose::DB::Object::Metadata::Column::BigInt'    => sub { $_[0]->tag('Numeric') },  # see Caveats for integer issues
 129   'Rose::DB::Object::Metadata::Column::Text'      => sub { $_[0]->tag('AlphaNumeric') },
 130   'Rose::DB::Object::Metadata::Column::Varchar'   => sub { $_[0]->tag('AlphaNumeric') },
 131   'Rose::DB::Object::Metadata::Column::Character' => sub { $_[0]->tag('AlphaNumeric') },
 132   'Rose::DB::Object::Metadata::Column::Numeric'   => sub { $_[0]->tag('Numeric', sub { $_[0]->tag('Accuracy', 5) }) },
 133   'Rose::DB::Object::Metadata::Column::Date'      => sub { $_[0]->tag('Date', sub { $_[0]->tag('Format', $date_format) }) },
 134   'Rose::DB::Object::Metadata::Column::Timestamp' => sub { $_[0]->tag('Date', sub { $_[0]->tag('Format', $date_format) }) },
 135   'Rose::DB::Object::Metadata::Column::Float'     => sub { $_[0]->tag('Numeric') },
 136   'Rose::DB::Object::Metadata::Column::Boolean'   => sub { $_[0]
 137     ->tag('AlphaNumeric')
 138     ->tag('Map', sub { $_[0]
 139       ->tag('From', 1)
 140       ->tag('To', t8('true'))
 141     })
 142     ->tag('Map', sub { $_[0]
 143       ->tag('From', 0)
 144       ->tag('To', t8('false'))
 145     })
 146     ->tag('Map', sub { $_[0]
 147       ->tag('From', '')
 148       ->tag('To', t8('false'))
 149     })
 150   },
 151 );
 152
 153 sub generate_export {
 154   my ($self) = @_;
 155
 156   # verify data
 157   $self->from && 'DateTime' eq ref $self->from or die 'need from date';
 158   $self->to   && 'DateTime' eq ref $self->to   or die 'need to date';
 159   $self->from <= $self->to                     or die 'from date must be earlier or equal than to date';
 160   $self->tables && @{ $self->tables }          or die 'need tables';
 161   for (@{ $self->tables }) {
 162     next if $known_tables{$_};
 163     die "unknown table '$_'";
 164   }
 165
 166   # get data from those tables and save to csv
 167   # for that we need to build queries that fetch all the columns
 168   for ($self->sorted_tables) {
 169     $self->do_csv_export($_);
 170   }
 171
 172   $self->do_datev_csv_export;
 173
 174   # write xml file
 175   $self->do_xml_file;
 176
 177   # add dtd
 178   $self->files->{'gdpdu-01-08-2002.dtd'} = File::Spec->catfile('users', 'gdpdu-01-08-2002.dtd');
 179
 180   # make zip
 181   my ($fh, $zipfile) = File::Temp::tempfile();
 182   my $zip            = Archive::Zip->new;
 183
 184   while (my ($name, $file) = each %{ $self->files }) {
 185     $zip->addFile($file, $name);
 186   }
 187
 188   $zip->writeToFileHandle($fh) == Archive::Zip::AZ_OK() or die 'error writing zip file';
 189   close($fh);
 190
 191   return $zipfile;
 192 }
 193
 194 sub do_xml_file {
 195   my ($self) = @_;
 196
 197   my ($fh, $filename) = File::Temp::tempfile();
 198   binmode($fh, ':utf8');
 199
 200   $self->files->{'INDEX.XML'} = $filename;
 201   push @{ $self->tempfiles }, $filename;
 202
 203   my $writer = XML::Writer->new(
 204     OUTPUT      => $fh,
 205     ENCODING    => 'UTF-8',
 206   );
 207
 208   $self->writer($writer);
 209   $self->writer->xmlDecl('UTF-8');
 210   $self->writer->doctype('DataSet', undef, "gdpdu-01-08-2002.dtd");
 211   $self->tag('DataSet', sub { $self
 212     ->tag('Version', '1.0')
 213     ->tag('DataSupplier', sub { $self
 214       ->tag('Name', $self->client_name)
 215       ->tag('Location', $self->client_location)
 216       ->tag('Comment', $self->make_comment)
 217     })
 218     ->tag('Media', sub { $self
 219       ->tag('Name', t8('DataSet #1', 1));
 220       for (reverse $self->sorted_tables) { $self  # see CAVEATS for table order
 221         ->table($_)
 222       }
 223       $self->do_datev_xml_table;
 224     })
 225   });
 226   close($fh);
 227 }
 228
 229 sub table {
 230   my ($self, $table) = @_;
 231   my $writer = $self->writer;
 232
 233   $self->tag('Table', sub { $self
 234     ->tag('URL', "$table.csv")
 235     ->tag('Name', $known_tables{$table}{name})
 236     ->tag('Description', $known_tables{$table}{description})
 237     ->tag('Validity', sub { $self
 238       ->tag('Range', sub { $self
 239         ->tag('From', $self->from->to_kivitendo(dateformat => 'dd.mm.yyyy'))
 240         ->tag('To',   $self->to->to_kivitendo(dateformat => 'dd.mm.yyyy'))
 241       })
 242       ->tag('Format', $date_format)
 243     })
 244     ->tag('UTF8')
 245     ->tag('DecimalSymbol', '.')
 246     ->tag('DigitGroupingSymbol', '|')     # see CAVEATS in documentation
 247     ->tag('Range', sub { $self
 248       ->tag('From', $self->csv_headers ? 2 : 1)
 249     })
 250     ->tag('VariableLength', sub { $self
 251       ->tag('ColumnDelimiter', ',')       # see CAVEATS for missing RecordDelimiter
 252       ->tag('TextEncapsulator', '"')
 253       ->columns($table)
 254       ->foreign_keys($table)
 255     })
 256   });
 257 }
 258
 259 sub _table_columns {
 260   my ($table) = @_;
 261   my $package = SL::DB::Helper::Mappings::get_package_for_table($table);
 262
 263   my %white_list;
 264   my $use_white_list = 0;
 265   if ($known_tables{$table}{columns}) {
 266     $use_white_list = 1;
 267     $white_list{$_} = 1 for @{ $known_tables{$table}{columns} || [] };
 268   }
 269
 270   # PrimaryKeys must come before regular columns, so partition first
 271   partition_by {
 272     $known_tables{$table}{primary_key}
 273       ? 1 * ($_ eq $known_tables{$table}{primary_key})
 274       : 1 * $_->is_primary_key_member
 275   } grep {
 276     $use_white_list ? $white_list{$_->name} : 1
 277   } $package->meta->columns;
 278 }
 279
 280 sub columns {
 281   my ($self, $table) = @_;
 282
 283   my %cols_by_primary_key = _table_columns($table);
 284
 285   for my $column (@{ $cols_by_primary_key{1} }) {
 286     my $type = $column_types{ ref $column };
 287
 288     die "unknown col type @{[ ref $column ]}" unless $type;
 289
 290     $self->tag('VariablePrimaryKey', sub { $self
 291       ->tag('Name', $column_titles{$table}{$column->name});
 292       $type->($self);
 293     })
 294   }
 295
 296   for my $column (@{ $cols_by_primary_key{0} }) {
 297     my $type = $column_types{ ref $column };
 298
 299     die "unknown col type @{[ ref $column]}" unless $type;
 300
 301     $self->tag('VariableColumn', sub { $self
 302       ->tag('Name', $column_titles{$table}{$column->name});
 303       $type->($self);
 304     })
 305   }
 306
 307   $self;
 308 }
 309
 310 sub foreign_keys {
 311   my ($self, $table) = @_;
 312   my $package = SL::DB::Helper::Mappings::get_package_for_table($table);
 313
 314   my %requested = map { $_ => 1 } @{ $self->tables };
 315
 316   for my $rel ($package->meta->foreign_keys) {
 317     next unless $requested{ $rel->class->meta->table };
 318
 319     # ok, now extract the columns used as foreign key
 320     my %key_columns = $rel->key_columns;
 321
 322     if (1 != keys %key_columns) {
 323       die "multi keys? we don't support this currently. fix it please";
 324     }
 325
 326     if ($table eq $rel->class->meta->table) {
 327       # self referential foreign keys are a PITA to export correctly. skip!
 328       next;
 329     }
 330
 331     $self->tag('ForeignKey', sub {
 332       $_[0]->tag('Name',  $column_titles{$table}{$_}) for keys %key_columns;
 333       $_[0]->tag('References', $rel->class->meta->table);
 334    });
 335   }
 336 }
 337
 338 sub do_datev_xml_table {
 339   my ($self) = @_;
 340   my $writer = $self->writer;
 341
 342   $self->tag('Table', sub { $self
 343     ->tag('URL', "transactions.csv")
 344     ->tag('Name', t8('Transactions'))
 345     ->tag('Description', t8('Transactions'))
 346     ->tag('Validity', sub { $self
 347       ->tag('Range', sub { $self
 348         ->tag('From', $self->from->to_kivitendo(dateformat => 'dd.mm.yyyy'))
 349         ->tag('To',   $self->to->to_kivitendo(dateformat => 'dd.mm.yyyy'))
 350       })
 351       ->tag('Format', $date_format)
 352     })
 353     ->tag('UTF8')
 354     ->tag('DecimalSymbol', '.')
 355     ->tag('DigitGroupingSymbol', '|')     # see CAVEATS in documentation
 356     ->tag('Range', sub { $self
 357       ->tag('From', $self->csv_headers ? 2 : 1)
 358     })
 359     ->tag('VariableLength', sub { $self
 360       ->tag('ColumnDelimiter', ',')       # see CAVEATS for missing RecordDelimiter
 361       ->tag('TextEncapsulator', '"')
 362       ->datev_columns
 363       ->datev_foreign_keys
 364     })
 365   });
 366 }
 367
 368 sub datev_columns {
 369   my ($self, $table) = @_;
 370
 371   my %cols_by_primary_key = partition_by { 1 * $datev_column_defs{$_}{primary_key} } @datev_columns;
 372
 373   for my $column (@{ $cols_by_primary_key{1} }) {
 374     my $type = $column_types{ $datev_column_defs{$column}{type} };
 375
 376     die "unknown col type @{[ $column ]}" unless $type;
 377
 378     $self->tag('VariablePrimaryKey', sub { $self
 379       ->tag('Name', $datev_column_defs{$column}{text});
 380       $type->($self);
 381     })
 382   }
 383
 384   for my $column (@{ $cols_by_primary_key{0} }) {
 385     my $type = $column_types{ $datev_column_defs{$column}{type} };
 386
 387     die "unknown col type @{[ ref $column]}" unless $type;
 388
 389     $self->tag('VariableColumn', sub { $self
 390       ->tag('Name', $datev_column_defs{$column}{text});
 391       $type->($self);
 392     })
 393   }
 394
 395   $self;
 396 }
 397
 398 sub datev_foreign_keys {
 399   my ($self) = @_;
 400   # hard code weeee
 401   $self->tag('ForeignKey', sub { $_[0]
 402     ->tag('Name', $datev_column_defs{customer_id}{text})
 403     ->tag('References', 'customer')
 404   });
 405   $self->tag('ForeignKey', sub { $_[0]
 406     ->tag('Name', $datev_column_defs{vendor_id}{text})
 407     ->tag('References', 'vendor')
 408   });
 409   $self->tag('ForeignKey', sub { $_[0]
 410     ->tag('Name', $datev_column_defs{$_}{text})
 411     ->tag('References', 'chart')
 412   }) for qw(debit_accno credit_accno tax_accno);
 413 }
 414
 415 sub do_datev_csv_export {
 416   my ($self) = @_;
 417
 418   my $datev = SL::DATEV->new(from => $self->from, to => $self->to);
 419
 420   $datev->generate_datev_data(from_to => $datev->fromto);
 421
 422   if ($datev->errors) {
 423     die [ $datev->errors ];
 424   }
 425
 426   for my $transaction (@{ $datev->{DATEV} }) {
 427     for my $entry (@{ $transaction }) {
 428       $entry->{sortkey} = join '-', map { lc } (DateTime->from_kivitendo($entry->{transdate})->strftime('%Y%m%d'), $entry->{name}, $entry->{reference});
 429     }
 430   }
 431
 432   my @transactions = sort_by { $_->[0]->{sortkey} } @{ $datev->{DATEV} };
 433
 434   my $csv = Text::CSV_XS->new({ binary => 1, eol => "\r\n", sep_char => ",", quote_char => '"' });
 435
 436   my ($fh, $filename) = File::Temp::tempfile();
 437   binmode($fh, ':utf8');
 438
 439   $self->files->{"transactions.csv"} = $filename;
 440   push @{ $self->tempfiles }, $filename;
 441
 442   if ($self->csv_headers) {
 443     $csv->print($fh, [ map { _normalize_cell($datev_column_defs{$_}{text}) } @datev_columns ]);
 444   }
 445
 446   for my $transaction (@transactions) {
 447     my $is_payment     = any { $_->{link} =~ m{A[PR]_paid} } @{ $transaction };
 448
 449     my ($soll, $haben) = map { $transaction->[$_] } ($transaction->[0]->{amount} > 0 ? (1, 0) : (0, 1));
 450     my $tax            = defined($soll->{tax_accno}) ? $soll : defined($haben->{tax_accno}) ? $haben : {};
 451     my $amount         = defined($soll->{net_amount}) ? $soll : $haben;
 452     $haben->{notes}    = ($haben->{memo} || $soll->{memo}) if $haben->{memo} || $soll->{memo};
 453     $haben->{notes}  //= '';
 454     $haben->{notes}    =  SL::HTML::Util->strip($haben->{notes});
 455
 456     my $tax_amount = defined $amount->{net_amount} ? abs($amount->{amount}) - abs($amount->{net_amount}) : 0;
 457
 458     $tax = {} if abs($tax_amount) < 0.001;
 459
 460     my %row            = (
 461       amount           => $::form->format_amount($myconfig, abs($amount->{amount}),5),
 462       debit_accno      => $soll->{accno},
 463       debit_accname    => $soll->{accname},
 464       debit_amount     => $::form->format_amount($myconfig, abs(-$soll->{amount}),5),
 465       debit_tax        => $soll->{tax_accno} ? $::form->format_amount($myconfig, $tax_amount, 5) : 0,
 466       credit_accno     => $haben->{accno},
 467       credit_accname   => $haben->{accname},
 468       credit_amount    => $::form->format_amount($myconfig, abs($haben->{amount}),5),,
 469       credit_tax       => $haben->{tax_accno} ? $::form->format_amount($myconfig, $tax_amount, 5) : 0,
 470       tax              => $::form->format_amount($myconfig, $tax_amount, 5),
 471       notes            => $haben->{notes},
 472       (map { ($_ => $tax->{$_})                    } qw(taxkey tax_accname tax_accno taxdescription)),
 473       (map { ($_ => ($haben->{$_} // $soll->{$_})) } qw(trans_id invnumber name vcnumber transdate gldate itime customer_id vendor_id)),
 474     );
 475
 476 #     if ($row{debit_amount} + $row{debit_tax} - ($row{credit_amount} + $row{credit_tax}) > 0.005) {
 477 #       $::lxdebug->dump(0,  "broken taxes", [ $transaction, \%row,  $row{debit_amount} + $row{debit_tax}, $row{credit_amount} + $row{credit_tax} ]);
 478 #     }
 479
 480     _normalize_cell($_) for values %row; # see CAVEATS
 481
 482     $csv->print($fh, [ map { $row{$_} } @datev_columns ]);
 483   }
 484
 485   # and build xml spec for it
 486 }
 487
 488 sub do_csv_export {
 489   my ($self, $table) = @_;
 490
 491   my $csv = Text::CSV_XS->new({ binary => 1, eol => "\r\n", sep_char => ",", quote_char => '"' });
 492
 493   my ($fh, $filename) = File::Temp::tempfile();
 494   binmode($fh, ':utf8');
 495
 496   $self->files->{"$table.csv"} = $filename;
 497   push @{ $self->tempfiles }, $filename;
 498
 499   # in the right order (primary keys first)
 500   my %cols_by_primary_key = _table_columns($table);
 501   my @columns = (@{ $cols_by_primary_key{1} }, @{ $cols_by_primary_key{0} });
 502   my %col_index = do { my $i = 0; map {; "$_" => $i++ } @columns };
 503
 504   if ($self->csv_headers) {
 505     $csv->print($fh, [ map { _normalize_cell($column_titles{$table}{$_->name}) } @columns ]) or die $csv->error_diag;
 506   }
 507
 508   # and normalize date stuff
 509   my @select_tokens = map { (ref $_) =~ /Time/ ? $_->name . '::date' : $_->name } @columns;
 510
 511   my @where_tokens;
 512   my @values;
 513   if ($known_tables{$table}{transdate}) {
 514     if ($self->from) {
 515       push @where_tokens, "$known_tables{$table}{transdate} >= ?";
 516       push @values, $self->from;
 517     }
 518     if ($self->to) {
 519       push @where_tokens, "$known_tables{$table}{transdate} <= ?";
 520       push @values, $self->to;
 521     }
 522   }
 523   if ($known_tables{$table}{tables}) {
 524     my ($col, @col_specs) = @{ $known_tables{$table}{tables} };
 525     my %ids;
 526     for (@col_specs) {
 527       my ($ftable, $fkey) = split /\./, $_;
 528       if (!exists $self->export_ids->{$ftable}{$fkey}) {
 529          # check if we forgot to keep it
 530          if (!grep { $_ eq $fkey } @{ $known_tables{$ftable}{keep} || [] }) {
 531            die "unknown table spec '$_' for table $table, did you forget to keep $fkey in $ftable?"
 532          } else {
 533            # hmm, most likely just an empty set.
 534            $self->export_ids->{$ftable}{$fkey} = {};
 535          }
 536       }
 537       $ids{$_}++ for keys %{ $self->export_ids->{$ftable}{$fkey} };
 538     }
 539     if (keys %ids) {
 540       push @where_tokens, "$col IN (@{[ join ',', ('?') x keys %ids ]})";
 541       push @values, keys %ids;
 542     } else {
 543       push @where_tokens, '1=0';
 544     }
 545   }
 546
 547   my $where_clause = @where_tokens ? 'WHERE ' . join ' AND ', @where_tokens : '';
 548
 549   my $query = "SELECT " . join(', ', @select_tokens) . " FROM $table $where_clause";
 550
 551   my $sth = $::form->get_standard_dbh->prepare($query);
 552   $sth->execute(@values) or $::form->dberror($query);
 553
 554   while (my $row = $sth->fetch) {
 555     for my $keep_col (@{ $known_tables{$table}{keep} || [] }) {
 556       next if !$row->[$col_index{$keep_col}];
 557       $self->export_ids->{$table}{$keep_col} ||= {};
 558       $self->export_ids->{$table}{$keep_col}{$row->[$col_index{$keep_col}]}++;
 559     }
 560     _normalize_cell($_) for @$row; # see CAVEATS
 561
 562     $csv->print($fh, $row) or $csv->error_diag;
 563   }
 564   $sth->finish();
 565 }
 566
 567 sub tag {
 568   my ($self, $tag, $content) = @_;
 569
 570   $self->writer->startTag($tag);
 571   if ('CODE' eq ref $content) {
 572     $content->($self);
 573   } else {
 574     $self->writer->characters($content);
 575   }
 576   $self->writer->endTag;
 577   return $self;
 578 }
 579
 580 sub make_comment {
 581   my $gobd_version  = API_VERSION();
 582   my $kivi_version  = $::form->read_version;
 583   my $person        = $::myconfig{name};
 584   my $contact       = join ', ',
 585     (t8("Email") . ": $::myconfig{email}" ) x!! $::myconfig{email},
 586     (t8("Tel")   . ": $::myconfig{tel}" )   x!! $::myconfig{tel},
 587     (t8("Fax")   . ": $::myconfig{fax}" )   x!! $::myconfig{fax};
 588
 589   t8('DataSet for GoBD version #1. Created with kivitendo #2 by #3 (#4)',
 590     $gobd_version, $kivi_version, $person, $contact
 591   );
 592 }
 593
 594 sub client_name {
 595   $_[0]->company
 596 }
 597
 598 sub client_location {
 599   $_[0]->location
 600 }
 601
 602 sub sorted_tables {
 603   my ($self) = @_;
 604
 605   my %given = map { $_ => 1 } @{ $self->tables };
 606
 607   grep { $given{$_} } @export_table_order;
 608 }
 609
 610 sub all_tables {
 611   my ($self, $yesno) = @_;
 612
 613   $self->tables(\@export_table_order) if $yesno;
 614 }
 615
 616 sub _normalize_cell {
 617   $_[0] =~ s/\r\n/ /g;
 618   $_[0] =~ s/,/;/g;
 619   $_[0] =~ s/"/'/g;
 620   $_[0] =~ s/!/./g;
 621   $_[0]
 622 }
 623
 624 sub init_files { +{} }
 625 sub init_export_ids { +{} }
 626 sub init_tempfiles { [] }
 627 sub init_tables { [ grep { $known_tables{$_} } @export_table_order ] }
 628 sub init_csv_headers { 1 }
 629
 630 sub API_VERSION {
 631   DateTime->new(year => 2002, month => 8, day => 14)->to_kivitendo;
 632 }
 633
 634 sub DESTROY {
 635   unlink $_ for @{ $_[0]->tempfiles || [] };
 636 }
 637
 638 1;
 639
 640 __END__
 641
 642 =encoding utf-8
 643
 644 =head1 NAME
 645
 646 SL::GoBD - IDEA export generator
 647
 648 =head1 FUNCTIONS
 649
 650 =over 4
 651
 652 =item C<new PARAMS>
 653
 654 Create new export object. C<PARAMS> may contain:
 655
 656 =over 4
 657
 658 =item company
 659
 660 The name of the company, needed for the supplier header
 661
 662 =item location
 663
 664 Location of the company, needed for the supplier header
 665
 666 =item from
 667
 668 =item to
 669
 670 Will only include records in the specified date range. Data pulled from other
 671 tables will be culled to match what is needed for these records.
 672
 673 =item csv_headers
 674
 675 Optional. If set, will include a header line in the exported CSV files. Default true.
 676
 677 =item tables
 678
 679 Ooptional list of tables to be exported. Defaults to all tables.
 680
 681 =item all_tables
 682
 683 Optional alternative to C<tables>, forces all known tables.
 684
 685 =back
 686
 687 =item C<generate_export>
 688
 689 Do the work. Will return an absolute path to a temp file where all export files
 690 are zipped together.
 691
 692 =back
 693
 694 =head1 CAVEATS
 695
 696 Sigh. There are a lot of issues with the IDEA software that were found out by
 697 trial and error.
 698
 699 =head2 Problems in the Specification
 700
 701 =over 4
 702
 703 =item *
 704
 705 The specced date format is capable of only C<YY>, C<YYYY>, C<MM>,
 706 and C<DD>. There are no timestamps or timezones.
 707
 708 =item *
 709
 710 Numbers have the same issue. There is not dedicated integer type, and hinting
 711 at an integer type by setting accuracy to 0 generates a warning for redundant
 712 accuracy.
 713
 714 Also the number parsing is documented to be fragile. Official docs state that
 715 behaviour for too low C<Accuracy> settings is undefined.
 716
 717 =item *
 718
 719 Foreign key definition is broken. Instead of giving column maps it assumes that
 720 foreign keys map to the primary keys given for the target table, and in that
 721 order. Also the target table must be known in full before defining a foreign key.
 722
 723 As a consequence any additional keys apart from primary keys are not possible.
 724 Self-referencing tables are also not possible.
 725
 726 =item *
 727
 728 The spec does not support splitting data sets into smaller chunks. For data
 729 sets that exceed 700MB the spec helpfully suggests: "Use a bigger medium, such
 730 as a DVD".
 731
 732 =item *
 733
 734 It is not possible to set an empty C<DigitGroupingSymbol> since then the import
 735 will just work with the default. This was asked in their forum, and the
 736 response actually was to use a bogus grouping symbol that is not used:
 737
 738   Einfache Lösung: Definieren Sie das Tausendertrennzeichen als Komma, auch
 739   wenn es nicht verwendet wird. Sollten Sie das Komma bereits als Feldtrenner
 740   verwenden, so wählen Sie als Tausendertrennzeichen eine Alternative wie das
 741   Pipe-Symbol |.
 742
 743 L<http://www.gdpdu-portal.com/forum/index.php?mode=thread&id=1392>
 744
 745 =item *
 746
 747 It is not possible to define a C<RecordDelimiter> with XML entities. &#x0A;
 748 generates the error message:
 749
 750   C<RecordDelimiter>-Wert (&#x0A;) sollte immer aus ein oder zwei Zeichen
 751   bestehen.
 752
 753 Instead we just use the implicit default RecordDelimiter CRLF.
 754
 755 =back
 756
 757 =head2 Bugs in the IDEA software
 758
 759 =over 4
 760
 761 =item *
 762
 763 The CSV import library used in IDEA is not able to parse newlines (or more
 764 exactly RecordDelimiter) in data. So this export substites all of these with
 765 spaces.
 766
 767 =item *
 768
 769 Neither it is able to parse escaped C<ColumnDelimiter> in data. It just splits
 770 on that symbol no matter what surrounds or preceeds it.
 771
 772 =item *
 773
 774 Oh and of course C<TextEncapsulator> is also not allowed in data. It's just
 775 stripped at the beginning and end of data.
 776
 777 =item *
 778
 779 And the character "!" is used internally as a warning signal and must not be
 780 present in the data as well.
 781
 782 =item *
 783
 784 C<VariableLength> data is truncated on import to 512 bytes (Note: it said
 785 characters, but since they are mutilating data into a single byte encoding
 786 anyway, they most likely meant bytes). The auditor recommends splitting into
 787 multiple columns.
 788
 789 =item *
 790
 791 Despite the standard specifying UTF-8 as a valid encoding the IDEA software
 792 will just downgrade everything to latin1.
 793
 794 =back
 795
 796 =head2 Problems outside of the software
 797
 798 =over 4
 799
 800 =item *
 801
 802 The law states that "all business related data" should be made available. In
 803 practice there's no definition for what makes data "business related", and
 804 different auditors seems to want different data.
 805
 806 Currently we export most of the transactional data with supplementing
 807 customers, vendors and chart of accounts.
 808
 809 =item *
 810
 811 While the standard explicitely state to provide data normalized, in practice
 812 autditors aren't trained database operators and can not create complex vies on
 813 normalized data on their own. The reason this works for other software is, that
 814 DATEV and SAP seem to have written import plugins for their internal formats in
 815 the IDEA software.
 816
 817 So what is really exported is not unlike a DATEV export. Each transaction gets
 818 splitted into chunks of 2 positions (3 with tax on one side). Those get
 819 denormalized into a single data row with credfit/debit/tax fields. The charts
 820 get denormalized into it as well, in addition to their account number serving
 821 as a foreign key.
 822
 823 Customers and vendors get denormalized into this as well, but are linked by ids
 824 to their tables. And the reason for this is...
 825
 826 =item *
 827
 828 Some auditors do not have a full license of the IDEA software, and
 829 can't do table joins.
 830
 831 =back
 832
 833 =head1 AUTHOR
 834
 835 Sven Schöling E<lt>s.schoeling@linet-services.deE<gt>
 836
 837 =cut