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