SL/Controller/CsvImport/Order.pm

   1 package SL::Controller::CsvImport::Order;
   2
   3
   4 use strict;
   5
   6 use List::MoreUtils qw(any);
   7
   8 use SL::Helper::Csv;
   9 use SL::DB::Order;
  10 use SL::DB::OrderItem;
  11 use SL::DB::Part;
  12 use SL::DB::PaymentTerm;
  13 use SL::DB::Contact;
  14 use SL::TransNumber;
  15
  16 use parent qw(SL::Controller::CsvImport::BaseMulti);
  17
  18
  19 use Rose::Object::MakeMethods::Generic
  20 (
  21  'scalar --get_set_init' => [ qw(settings languages_by all_parts parts_by all_contacts contacts_by) ],
  22 );
  23
  24
  25 sub init_class {
  26   my ($self) = @_;
  27   $self->class(['SL::DB::Order', 'SL::DB::OrderItem']);
  28 }
  29
  30
  31 sub init_settings {
  32   my ($self) = @_;
  33
  34   return { map { ( $_ => $self->controller->profile->get($_) ) } qw(order_column item_column) };
  35 }
  36
  37
  38 sub init_profile {
  39   my ($self) = @_;
  40
  41   my $profile = $self->SUPER::init_profile;
  42
  43   foreach my $p (@{ $profile }) {
  44     my $prof = $p->{profile};
  45     if ($p->{row_ident} eq 'Order') {
  46       # no need to handle
  47       delete @{$prof}{qw(delivery_customer_id delivery_vendor_id proforma quotation amount netamount)};
  48       # handable, but not handled by now
  49     }
  50     if ($p->{row_ident} eq 'OrderItem') {
  51       delete @{$prof}{qw(trans_id)};
  52     }
  53   }
  54
  55   return $profile;
  56 }
  57
  58
  59 sub setup_displayable_columns {
  60   my ($self) = @_;
  61
  62   $self->SUPER::setup_displayable_columns;
  63
  64   $self->add_displayable_columns('Order',
  65                                  { name => 'datatype',         description => $::locale->text('Zeilenkennung')                  },
  66                                  { name => 'verify_amount',    description => $::locale->text('Amount (for verification)')      },
  67                                  { name => 'verify_netamount', description => $::locale->text('Net amount (for verification)')  },
  68                                  { name => 'taxincluded',      description => $::locale->text('Tax Included')                   },
  69                                  { name => 'customer',         description => $::locale->text('Customer (name)')                },
  70                                  { name => 'customernumber',   description => $::locale->text('Customer Number')                },
  71                                  { name => 'customer_id',      description => $::locale->text('Customer (database ID)')         },
  72                                  { name => 'vendor',           description => $::locale->text('Vendor (name)')                  },
  73                                  { name => 'vendornumber',     description => $::locale->text('Vendor Number')                  },
  74                                  { name => 'vendor_id',        description => $::locale->text('Vendor (database ID)')           },
  75                                  { name => 'language_id',      description => $::locale->text('Language (database ID)')         },
  76                                  { name => 'language',         description => $::locale->text('Language (name)')                },
  77                                  { name => 'payment_id',       description => $::locale->text('Payment terms (database ID)')    },
  78                                  { name => 'payment',          description => $::locale->text('Payment terms (name)')           },
  79                                  { name => 'taxzone_id',       description => $::locale->text('Steuersatz')                     },
  80                                  { name => 'contact_id',       description => $::locale->text('Contact Person (database ID)')   },
  81                                  { name => 'contact',          description => $::locale->text('Contact Person (name)')          },
  82                                 );
  83
  84   $self->add_displayable_columns('OrderItem',
  85                                  { name => 'parts_id',       description => $::locale->text('Part (database ID)')          },
  86                                  { name => 'partnumber',     description => $::locale->text('Part Number')                 },
  87                                 );
  88 }
  89
  90
  91 sub init_languages_by {
  92   my ($self) = @_;
  93
  94   return { map { my $col = $_; ( $col => { map { ( $_->$col => $_ ) } @{ $self->all_languages } } ) } qw(id description article_code) };
  95 }
  96
  97 sub init_all_parts {
  98   my ($self) = @_;
  99
 100   return SL::DB::Manager::Part->get_all;
 101 }
 102
 103 sub init_parts_by {
 104   my ($self) = @_;
 105
 106   return { map { my $col = $_; ( $col => { map { ( $_->$col => $_ ) } @{ $self->all_parts } } ) } qw(id partnumber ean description) };
 107 }
 108
 109 sub init_all_contacts {
 110   my ($self) = @_;
 111
 112   return SL::DB::Manager::Contact->get_all;
 113 }
 114
 115 sub init_contacts_by {
 116   my ($self) = @_;
 117
 118   my $cby = { map { my $col = $_; ( $col => { map { ( $_->$col => $_ ) } @{ $self->all_contacts } } ) } qw(cp_id cp_name) };
 119
 120   # by customer/vendor id  _and_  contact person id
 121   $cby->{'cp_cv_id+cp_id'} = { map { ( $_->cp_cv_id . '+' . $_->cp_id => $_ ) } @{ $self->all_contacts } };
 122
 123   return $cby;
 124 }
 125
 126 sub check_objects {
 127   my ($self) = @_;
 128
 129   $self->controller->track_progress(phase => 'building data', progress => 0);
 130
 131   my $i;
 132   my $num_data = scalar @{ $self->controller->data };
 133   foreach my $entry (@{ $self->controller->data }) {
 134     $self->controller->track_progress(progress => $i/$num_data * 100) if $i % 100 == 0;
 135
 136     if ($entry->{raw_data}->{datatype} eq $self->settings->{'order_column'}) {
 137
 138       my $vc_obj;
 139       if (any { $entry->{raw_data}->{$_} } qw(customer customernumber customer_id)) {
 140         $self->check_vc($entry, 'customer_id');
 141         $vc_obj = SL::DB::Customer->new(id => $entry->{object}->customer_id)->load if $entry->{object}->customer_id;
 142       } elsif (any { $entry->{raw_data}->{$_} } qw(vendor vendornumber vendor_id)) {
 143         $self->check_vc($entry, 'vendor_id');
 144         $vc_obj = SL::DB::Vendor->new(id => $entry->{object}->vendor_id)->load if $entry->{object}->vendor_id;
 145       } else {
 146         push @{ $entry->{errors} }, $::locale->text('Error: Customer/vendor missing');
 147       }
 148
 149       $self->check_contact($entry);
 150       $self->check_language($entry);
 151       $self->check_payment($entry);
 152
 153       if ($vc_obj) {
 154         # copy from customer if not given
 155         foreach (qw(payment_id language_id taxzone_id)) {
 156           $entry->{object}->$_($vc_obj->$_) unless $entry->{object}->$_;
 157         }
 158       }
 159
 160       # ToDo: salesman and emloyee by name
 161       # salesman from customer or login if not given
 162       if (!$entry->{object}->salesman) {
 163         if ($vc_obj && $vc_obj->salesman_id) {
 164           $entry->{object}->salesman(SL::DB::Manager::Employee->find_by(id => $vc_obj->salesman_id));
 165         } else {
 166           $entry->{object}->salesman(SL::DB::Manager::Employee->find_by(login => $::myconfig{login}));
 167         }
 168       }
 169
 170       # employee from login if not given
 171       if (!$entry->{object}->employee_id) {
 172         $entry->{object}->employee_id(SL::DB::Manager::Employee->find_by(login => $::myconfig{login})->id);
 173       }
 174
 175     }
 176   }
 177
 178   $self->add_info_columns($self->settings->{'order_column'},
 179                           { header => $::locale->text('Customer/Vendor'), method => 'vc_name' });
 180   $self->add_columns($self->settings->{'order_column'},
 181                      map { "${_}_id" } grep { exists $self->controller->data->[0]->{raw_data}->{$_} } qw(business payment));
 182
 183
 184   foreach my $entry (@{ $self->controller->data }) {
 185     if ($entry->{raw_data}->{datatype} eq $self->settings->{'item_column'} && $entry->{object}->can('part')) {
 186
 187       next if !$self->check_part($entry);
 188
 189       my $part_obj = SL::DB::Part->new(id => $entry->{object}->parts_id)->load;
 190
 191       # copy from part if not given
 192       $entry->{object}->description($part_obj->description) unless $entry->{object}->description;
 193       $entry->{object}->longdescription($part_obj->notes)   unless $entry->{object}->longdescription;
 194       $entry->{object}->unit($part_obj->unit)               unless $entry->{object}->unit;
 195
 196       # set to 0 if not given
 197       $entry->{object}->discount(0)      unless $entry->{object}->discount;
 198       $entry->{object}->ship(0)          unless $entry->{object}->ship;
 199     }
 200   }
 201
 202   $self->add_info_columns($self->settings->{'item_column'},
 203                           { header => $::locale->text('Part Number'), method => 'partnumber' });
 204
 205   # add orderitems to order
 206   my $order_entry;
 207   my @orderitems;
 208   foreach my $entry (@{ $self->controller->data }) {
 209     # search first Order
 210     if ($entry->{raw_data}->{datatype} eq $self->settings->{'order_column'}) {
 211
 212       # new order entry: add collected orderitems to the last one
 213       if (defined $order_entry) {
 214         $order_entry->{object}->orderitems(@orderitems);
 215         @orderitems = ();
 216       }
 217
 218       $order_entry = $entry;
 219
 220     } elsif ( defined $order_entry && $entry->{raw_data}->{datatype} eq $self->settings->{'item_column'} ) {
 221       # collect orderitems to add to order (if they have no errors)
 222       # ( add_orderitems does not work here if we want to call
 223       #   calculate_prices_and_taxes afterwards ...
 224       #   so collect orderitems and add them at once)
 225       if (scalar @{ $entry->{errors} } == 0) {
 226         push @orderitems, $entry->{object};
 227       }
 228     }
 229   }
 230   # add last collected orderitems to last order
 231   if ($order_entry) {
 232     $order_entry->{object}->orderitems(@orderitems);
 233   }
 234
 235   # calculate prices and taxes
 236   foreach my $entry (@{ $self->controller->data }) {
 237     next if @{ $entry->{errors} };
 238
 239     if ($entry->{raw_data}->{datatype} eq $self->settings->{'order_column'}) {
 240
 241       $entry->{object}->calculate_prices_and_taxes;
 242
 243       $entry->{info_data}->{calc_amount}    = $entry->{object}->amount_as_number;
 244       $entry->{info_data}->{calc_netamount} = $entry->{object}->netamount_as_number;
 245     }
 246   }
 247
 248   # If amounts are given, show calculated amounts as info and given amounts (verify_xxx).
 249   # And throw an error if the differences are too big.
 250   my $max_diff = 0.02;
 251   my @to_verify = ( { column      => 'amount',
 252                       raw_column  => 'verify_amount',
 253                       info_header => 'Calc. Amount',
 254                       info_method => 'calc_amount',
 255                       err_msg     => 'Amounts differ too much',
 256                     },
 257                     { column      => 'netamount',
 258                       raw_column  => 'verify_netamount',
 259                       info_header => 'Calc. Net amount',
 260                       info_method => 'calc_netamount',
 261                       err_msg     => 'Net amounts differ too much',
 262                     } );
 263
 264   foreach my $tv (@to_verify) {
 265     if (exists $self->controller->data->[0]->{raw_data}->{ $tv->{raw_column} }) {
 266       $self->add_raw_data_columns($self->settings->{'order_column'}, $tv->{raw_column});
 267       $self->add_info_columns($self->settings->{'order_column'},
 268                               { header => $::locale->text($tv->{info_header}), method => $tv->{info_method} });
 269     }
 270
 271     # check differences
 272     foreach my $entry (@{ $self->controller->data }) {
 273       next if @{ $entry->{errors} };
 274       if ($entry->{raw_data}->{datatype} eq $self->settings->{'order_column'}) {
 275         next if !$entry->{raw_data}->{ $tv->{raw_column} };
 276         my $parsed_value = $::form->parse_amount(\%::myconfig, $entry->{raw_data}->{ $tv->{raw_column} });
 277         if (abs($entry->{object}->${ \$tv->{column} } - $parsed_value) > $max_diff) {
 278           push @{ $entry->{errors} }, $::locale->text($tv->{err_msg});
 279         }
 280       }
 281     }
 282   }
 283
 284   # If order has errors set error for orderitems as well
 285   my $order_entry;
 286   foreach my $entry (@{ $self->controller->data }) {
 287     # Search first order
 288     if ($entry->{raw_data}->{datatype} eq $self->settings->{'order_column'}) {
 289       $order_entry = $entry;
 290     } elsif ( defined $order_entry
 291               && $entry->{raw_data}->{datatype} eq $self->settings->{'item_column'}
 292               && scalar @{ $order_entry->{errors} } > 0 ) {
 293       push @{ $entry->{errors} }, $::locale->text('order not valid for this orderitem!');
 294     }
 295   }
 296
 297 }
 298
 299
 300 sub check_language {
 301   my ($self, $entry) = @_;
 302
 303   my $object = $entry->{object};
 304
 305   # Check whether or not language ID is valid.
 306   if ($object->language_id && !$self->languages_by->{id}->{ $object->language_id }) {
 307     push @{ $entry->{errors} }, $::locale->text('Error: Invalid language');
 308     return 0;
 309   }
 310
 311   # Map name to ID if given.
 312   if (!$object->language_id && $entry->{raw_data}->{language}) {
 313     my $language = $self->languages_by->{description}->{  $entry->{raw_data}->{language} }
 314                 || $self->languages_by->{article_code}->{ $entry->{raw_data}->{language} };
 315
 316     if (!$language) {
 317       push @{ $entry->{errors} }, $::locale->text('Error: Invalid language');
 318       return 0;
 319     }
 320
 321     $object->language_id($language->id);
 322   }
 323
 324   if ($object->language_id) {
 325     $entry->{info_data}->{language} = $self->languages_by->{id}->{ $object->language_id }->description;
 326   }
 327
 328   return 1;
 329 }
 330
 331 sub check_part {
 332   my ($self, $entry) = @_;
 333
 334   my $object = $entry->{object};
 335
 336   # Check wether or non part ID is valid.
 337   if ($object->parts_id && !$self->parts_by->{id}->{ $object->parts_id }) {
 338     push @{ $entry->{errors} }, $::locale->text('Error: Invalid part');
 339     return 0;
 340   }
 341
 342   # Map number to ID if given.
 343   if (!$object->parts_id && $entry->{raw_data}->{partnumber}) {
 344     my $part = $self->parts_by->{partnumber}->{ $entry->{raw_data}->{partnumber} };
 345     if (!$part) {
 346       push @{ $entry->{errors} }, $::locale->text('Error: Invalid part');
 347       return 0;
 348     }
 349
 350     $object->parts_id($part->id);
 351   }
 352
 353   if ($object->parts_id) {
 354     $entry->{info_data}->{partnumber} = $self->parts_by->{id}->{ $object->parts_id }->partnumber;
 355   } else {
 356     push @{ $entry->{errors} }, $::locale->text('Error: Part not found');
 357     return 0;
 358   }
 359
 360   return 1;
 361 }
 362
 363 sub check_contact {
 364   my ($self, $entry) = @_;
 365
 366   my $object = $entry->{object};
 367
 368   # Check wether or non contact ID is valid.
 369   if ($object->cp_id && !$self->contacts_by->{cp_id}->{ $object->cp_id }) {
 370     push @{ $entry->{errors} }, $::locale->text('Error: Invalid contact');
 371     return 0;
 372   }
 373
 374   # Map number to ID if given.
 375   if (!$object->cp_id && $entry->{raw_data}->{contact}) {
 376     my $cp = $self->contacts_by->{cp_name}->{ $entry->{raw_data}->{contact} };
 377     if (!$cp) {
 378       push @{ $entry->{errors} }, $::locale->text('Error: Invalid contact');
 379       return 0;
 380     }
 381
 382     $object->cp_id($cp->cp_id);
 383   }
 384
 385   # Check if the contact belongs to this customer/vendor.
 386   if ($object->cp_id && $object->customer_id && !$self->contacts_by->{'cp_cv_id+cp_id'}) {
 387     push @{ $entry->{errors} }, $::locale->text('Error: Contact not found for this customer/vendor');
 388     return 0;
 389   }
 390
 391   if ($object->cp_id) {
 392     $entry->{info_data}->{contact} = $self->contacts_by->{cp_id}->{ $object->cp_id }->cp_name;
 393   }
 394
 395   return 1;
 396 }
 397
 398 sub save_objects {
 399   my ($self, %params) = @_;
 400
 401   # set order number and collect to save
 402   my $objects_to_save;
 403   foreach my $entry (@{ $self->controller->data }) {
 404     next if @{ $entry->{errors} };
 405
 406     if ($entry->{raw_data}->{datatype} eq $self->settings->{'order_column'} && !$entry->{object}->ordnumber) {
 407       my $number = SL::TransNumber->new(type        => 'sales_order',
 408                                         save        => 1);
 409       $entry->{object}->ordnumber($number->create_unique());
 410     }
 411
 412     push @{ $objects_to_save }, $entry;
 413   }
 414
 415   $self->SUPER::save_objects(data => $objects_to_save);
 416 }
 417
 418
 419 1;