SL/Controller/Part.pm

   1 package SL::Controller::Part;
   2
   3 use strict;
   4 use parent qw(SL::Controller::Base);
   5
   6 use Clone qw(clone);
   7 use SL::DB::Part;
   8 use SL::DB::PartsGroup;
   9 use SL::DB::PriceRuleItem;
  10 use SL::DB::Shop;
  11 use SL::Controller::Helper::GetModels;
  12 use SL::Locale::String qw(t8);
  13 use SL::JSON;
  14 use List::Util qw(sum);
  15 use SL::Helper::Flash;
  16 use Data::Dumper;
  17 use DateTime;
  18 use SL::DB::History;
  19 use SL::DB::Helper::ValidateAssembly qw(validate_assembly);
  20 use SL::CVar;
  21 use SL::MoreCommon qw(save_form);
  22 use Carp;
  23 use SL::Presenter::EscapedText qw(escape is_escaped);
  24 use SL::Presenter::Tag qw(select_tag);
  25
  26 use Rose::Object::MakeMethods::Generic (
  27   'scalar --get_set_init' => [ qw(parts models part p warehouses multi_items_models
  28                                   makemodels shops_not_assigned
  29                                   customerprices
  30                                   orphaned
  31                                   assortment assortment_items assembly assembly_items
  32                                   all_pricegroups all_translations all_partsgroups all_units
  33                                   all_buchungsgruppen all_payment_terms all_warehouses
  34                                   parts_classification_filter
  35                                   all_languages all_units all_price_factors) ],
  36   'scalar'                => [ qw(warehouse bin) ],
  37 );
  38
  39 # safety
  40 __PACKAGE__->run_before(sub { $::auth->assert('part_service_assembly_edit') },
  41                         except => [ qw(ajax_autocomplete part_picker_search part_picker_result) ]);
  42
  43 __PACKAGE__->run_before('check_part_id', only   => [ qw(edit delete) ]);
  44
  45 __PACKAGE__->run_before('normalize_text_blocks');
  46
  47 # actions for editing parts
  48 #
  49 sub action_add_part {
  50   my ($self, %params) = @_;
  51
  52   $self->part( SL::DB::Part->new_part );
  53   $self->add;
  54 };
  55
  56 sub action_add_service {
  57   my ($self, %params) = @_;
  58
  59   $self->part( SL::DB::Part->new_service );
  60   $self->add;
  61 };
  62
  63 sub action_add_assembly {
  64   my ($self, %params) = @_;
  65
  66   $self->part( SL::DB::Part->new_assembly );
  67   $self->add;
  68 };
  69
  70 sub action_add_assortment {
  71   my ($self, %params) = @_;
  72
  73   $self->part( SL::DB::Part->new_assortment );
  74   $self->add;
  75 };
  76
  77 sub action_add_from_record {
  78   my ($self) = @_;
  79
  80   check_has_valid_part_type($::form->{part}{part_type});
  81
  82   die 'parts_classification_type must be "sales" or "purchases"'
  83     unless $::form->{parts_classification_type} =~ m/^(sales|purchases)$/;
  84
  85   $self->parse_form;
  86   $self->add;
  87 }
  88
  89 sub action_add {
  90   my ($self) = @_;
  91
  92   check_has_valid_part_type($::form->{part_type});
  93
  94   $self->action_add_part       if $::form->{part_type} eq 'part';
  95   $self->action_add_service    if $::form->{part_type} eq 'service';
  96   $self->action_add_assembly   if $::form->{part_type} eq 'assembly';
  97   $self->action_add_assortment if $::form->{part_type} eq 'assortment';
  98 };
  99
 100 sub action_save {
 101   my ($self, %params) = @_;
 102
 103   # checks that depend only on submitted $::form
 104   $self->check_form or return $self->js->render;
 105
 106   my $is_new = !$self->part->id; # $ part gets loaded here
 107
 108   # check that the part hasn't been modified
 109   unless ( $is_new ) {
 110     $self->check_part_not_modified or
 111       return $self->js->error(t8('The document has been changed by another user. Please reopen it in another window and copy the changes to the new window'))->render;
 112   }
 113
 114   if (    $is_new
 115        && $::form->{part}{partnumber}
 116        && SL::DB::Manager::Part->find_by(partnumber => $::form->{part}{partnumber})
 117      ) {
 118     return $self->js->error(t8('The partnumber is already being used'))->render;
 119   }
 120
 121   $self->parse_form;
 122
 123   my @errors = $self->part->validate;
 124   return $self->js->error(@errors)->render if @errors;
 125
 126   # $self->part has been loaded, parsed and validated without errors and is ready to be saved
 127   $self->part->db->with_transaction(sub {
 128
 129     if ( $params{save_as_new} ) {
 130       $self->part( $self->part->clone_and_reset_deep );
 131       $self->part->partnumber(undef); # will be assigned by _before_save_set_partnumber
 132     };
 133
 134     $self->part->save(cascade => 1);
 135
 136     SL::DB::History->new(
 137       trans_id    => $self->part->id,
 138       snumbers    => 'partnumber_' . $self->part->partnumber,
 139       employee_id => SL::DB::Manager::Employee->current->id,
 140       what_done   => 'part',
 141       addition    => 'SAVED',
 142     )->save();
 143
 144     CVar->save_custom_variables(
 145         dbh          => $self->part->db->dbh,
 146         module       => 'IC',
 147         trans_id     => $self->part->id,
 148         variables    => $::form, # $::form->{cvar} would be nicer
 149         always_valid => 1,
 150     );
 151
 152     1;
 153   }) or return $self->js->error(t8('The item couldn\'t be saved!') . " " . $self->part->db->error )->render;
 154
 155   ;
 156   flash_later('info', $is_new ? t8('The item has been created.') . " " . $self->part->displayable_name : t8('The item has been saved.'));
 157
 158   if ( $::form->{callback} ) {
 159     $self->redirect_to($::form->unescape($::form->{callback}) . '&new_parts_id=' . $self->part->id);
 160
 161   } else {
 162     # default behaviour after save: reload item, this also resets last_modification!
 163     $self->redirect_to(controller => 'Part', action => 'edit', 'part.id' => $self->part->id);
 164   }
 165 }
 166
 167 sub action_save_as_new {
 168   my ($self) = @_;
 169   $self->action_save(save_as_new=>1);
 170 }
 171
 172 sub action_delete {
 173   my ($self) = @_;
 174
 175   my $db = $self->part->db; # $self->part has a get_set_init on $::form
 176
 177   my $partnumber = $self->part->partnumber; # remember for history log
 178
 179   $db->do_transaction(
 180     sub {
 181
 182       # delete part, together with relationships that don't already
 183       # have an ON DELETE CASCADE, e.g. makemodel and translation.
 184       $self->part->delete(cascade => 1);
 185
 186       SL::DB::History->new(
 187         trans_id    => $self->part->id,
 188         snumbers    => 'partnumber_' . $partnumber,
 189         employee_id => SL::DB::Manager::Employee->current->id,
 190         what_done   => 'part',
 191         addition    => 'DELETED',
 192       )->save();
 193       1;
 194   }) or return $self->js->error(t8('The item couldn\'t be deleted!') . " " . $self->part->db->error)->render;
 195
 196   flash_later('info', t8('The item has been deleted.'));
 197   if ( $::form->{callback} ) {
 198     $self->redirect_to($::form->unescape($::form->{callback}));
 199   } else {
 200     $self->redirect_to(controller => 'ic.pl', action => 'search', searchitems => 'article');
 201   }
 202 }
 203
 204 sub action_use_as_new {
 205   my ($self, %params) = @_;
 206
 207   my $oldpart = SL::DB::Manager::Part->find_by( id => $::form->{old_id}) or die "can't find old part";
 208   $::form->{oldpartnumber} = $oldpart->partnumber;
 209
 210   $self->part($oldpart->clone_and_reset_deep);
 211   $self->parse_form;
 212   $self->part->partnumber(undef);
 213
 214   $self->render_form;
 215 }
 216
 217 sub action_edit {
 218   my ($self, %params) = @_;
 219
 220   $self->render_form;
 221 }
 222
 223 sub render_form {
 224   my ($self, %params) = @_;
 225
 226   $self->_set_javascript;
 227   $self->_setup_form_action_bar;
 228
 229   my (%assortment_vars, %assembly_vars);
 230   %assortment_vars = %{ $self->prepare_assortment_render_vars } if $self->part->is_assortment;
 231   %assembly_vars   = %{ $self->prepare_assembly_render_vars   } if $self->part->is_assembly;
 232
 233   $params{CUSTOM_VARIABLES}  = CVar->get_custom_variables(module => 'IC', trans_id => $self->part->id);
 234   $_->{valid}                = 1 for @{ $params{CUSTOM_VARIABLES} };
 235
 236   CVar->render_inputs('variables' => $params{CUSTOM_VARIABLES}, show_disabled_message => 1, partsgroup_id => $self->part->partsgroup_id)
 237     if (scalar @{ $params{CUSTOM_VARIABLES} });
 238
 239   my %title_hash = ( part       => t8('Edit Part'),
 240                      assembly   => t8('Edit Assembly'),
 241                      service    => t8('Edit Service'),
 242                      assortment => t8('Edit Assortment'),
 243                    );
 244
 245   $self->part->prices([])       unless $self->part->prices;
 246   $self->part->translations([]) unless $self->part->translations;
 247
 248   $self->render(
 249     'part/form',
 250     title             => $title_hash{$self->part->part_type},
 251     %assortment_vars,
 252     %assembly_vars,
 253     translations_map  => { map { ($_->language_id   => $_) } @{$self->part->translations} },
 254     prices_map        => { map { ($_->pricegroup_id => $_) } @{$self->part->prices      } },
 255     oldpartnumber     => $::form->{oldpartnumber},
 256     old_id            => $::form->{old_id},
 257     %params,
 258   );
 259 }
 260
 261 sub action_history {
 262   my ($self) = @_;
 263
 264   my $history_entries = SL::DB::Part->new(id => $::form->{part}{id})->history_entries;
 265   $_[0]->render('part/history', { layout => 0 },
 266                                   history_entries => $history_entries);
 267 }
 268
 269 sub action_update_item_totals {
 270   my ($self) = @_;
 271
 272   my $part_type = $::form->{part_type};
 273   die unless $part_type =~ /^(assortment|assembly)$/;
 274
 275   my $sellprice_sum = $self->recalc_item_totals(part_type => $part_type, price_type => 'sellcost');
 276   my $lastcost_sum  = $self->recalc_item_totals(part_type => $part_type, price_type => 'lastcost');
 277
 278   my $sum_diff      = $sellprice_sum-$lastcost_sum;
 279
 280   $self->js
 281     ->html('#items_sellprice_sum',       $::form->format_amount(\%::myconfig, $sellprice_sum, 2, 0))
 282     ->html('#items_lastcost_sum',        $::form->format_amount(\%::myconfig, $lastcost_sum,  2, 0))
 283     ->html('#items_sum_diff',            $::form->format_amount(\%::myconfig, $sum_diff,      2, 0))
 284     ->html('#items_sellprice_sum_basic', $::form->format_amount(\%::myconfig, $sellprice_sum, 2, 0))
 285     ->html('#items_lastcost_sum_basic',  $::form->format_amount(\%::myconfig, $lastcost_sum,  2, 0))
 286     ->no_flash_clear->render();
 287 }
 288
 289 sub action_add_multi_assortment_items {
 290   my ($self) = @_;
 291
 292   my $item_objects = $self->parse_add_items_to_objects(part_type => 'assortment');
 293   my $html         = $self->render_assortment_items_to_html($item_objects);
 294
 295   $self->js->run('kivi.Part.close_picker_dialogs')
 296            ->append('#assortment_rows', $html)
 297            ->run('kivi.Part.renumber_positions')
 298            ->run('kivi.Part.assortment_recalc')
 299            ->render();
 300 }
 301
 302 sub action_add_multi_assembly_items {
 303   my ($self) = @_;
 304
 305   my $item_objects = $self->parse_add_items_to_objects(part_type => 'assembly');
 306   my @checked_objects;
 307   foreach my $item (@{$item_objects}) {
 308     my $errstr = validate_assembly($item->part,$self->part);
 309     $self->js->flash('error',$errstr) if     $errstr;
 310     push (@checked_objects,$item)     unless $errstr;
 311   }
 312
 313   my $html = $self->render_assembly_items_to_html(\@checked_objects);
 314
 315   $self->js->run('kivi.Part.close_picker_dialogs')
 316            ->append('#assembly_rows', $html)
 317            ->run('kivi.Part.renumber_positions')
 318            ->run('kivi.Part.assembly_recalc')
 319            ->render();
 320 }
 321
 322 sub action_add_assortment_item {
 323   my ($self, %params) = @_;
 324
 325   validate_add_items() or return $self->js->error(t8("No part was selected."))->render;
 326
 327   carp('Too many objects passed to add_assortment_item') if @{$::form->{add_items}} > 1;
 328
 329   my $add_item_id = $::form->{add_items}->[0]->{parts_id};
 330   if ( $add_item_id && grep { $add_item_id == $_->parts_id } @{ $self->assortment_items } ) {
 331     return $self->js->flash('error', t8("This part has already been added."))->render;
 332   };
 333
 334   my $number_of_items = scalar @{$self->assortment_items};
 335   my $item_objects    = $self->parse_add_items_to_objects(part_type => 'assortment');
 336   my $html            = $self->render_assortment_items_to_html($item_objects, $number_of_items);
 337
 338   push(@{$self->assortment_items}, @{$item_objects});
 339   my $part = SL::DB::Part->new(part_type => 'assortment');
 340   $part->assortment_items(@{$self->assortment_items});
 341   my $items_sellprice_sum = $part->items_sellprice_sum;
 342   my $items_lastcost_sum  = $part->items_lastcost_sum;
 343   my $items_sum_diff      = $items_sellprice_sum - $items_lastcost_sum;
 344
 345   $self->js
 346     ->append('#assortment_rows'        , $html)  # append in tbody
 347     ->val('.add_assortment_item_input' , '')
 348     ->run('kivi.Part.focus_last_assortment_input')
 349     ->html("#items_sellprice_sum", $::form->format_amount(\%::myconfig, $items_sellprice_sum, 2, 0))
 350     ->html("#items_lastcost_sum",  $::form->format_amount(\%::myconfig, $items_lastcost_sum,  2, 0))
 351     ->html("#items_sum_diff",      $::form->format_amount(\%::myconfig, $items_sum_diff,      2, 0))
 352     ->html('#items_sellprice_sum_basic', $::form->format_amount(\%::myconfig, $items_sellprice_sum, 2, 0))
 353     ->html('#items_lastcost_sum_basic',  $::form->format_amount(\%::myconfig, $items_lastcost_sum,  2, 0))
 354     ->render;
 355 }
 356
 357 sub action_add_assembly_item {
 358   my ($self) = @_;
 359
 360   validate_add_items() or return $self->js->error(t8("No part was selected."))->render;
 361
 362   carp('Too many objects passed to add_assembly_item') if @{$::form->{add_items}} > 1;
 363
 364   my $add_item_id = $::form->{add_items}->[0]->{parts_id};
 365
 366   my $duplicate_warning = 0; # duplicates are allowed, just warn
 367   if ( $add_item_id && grep { $add_item_id == $_->parts_id } @{ $self->assembly_items } ) {
 368     $duplicate_warning++;
 369   };
 370
 371   my $number_of_items = scalar @{$self->assembly_items};
 372   my $item_objects    = $self->parse_add_items_to_objects(part_type => 'assembly');
 373   if ($add_item_id ) {
 374     foreach my $item (@{$item_objects}) {
 375       my $errstr = validate_assembly($item->part,$self->part);
 376       return $self->js->flash('error',$errstr)->render if $errstr;
 377     }
 378   }
 379
 380
 381   my $html            = $self->render_assembly_items_to_html($item_objects, $number_of_items);
 382
 383   $self->js->flash('info', t8("This part has already been added.")) if $duplicate_warning;
 384
 385   push(@{$self->assembly_items}, @{$item_objects});
 386   my $part = SL::DB::Part->new(part_type => 'assembly');
 387   $part->assemblies(@{$self->assembly_items});
 388   my $items_sellprice_sum = $part->items_sellprice_sum;
 389   my $items_lastcost_sum  = $part->items_lastcost_sum;
 390   my $items_sum_diff      = $items_sellprice_sum - $items_lastcost_sum;
 391
 392   $self->js
 393     ->append('#assembly_rows', $html)  # append in tbody
 394     ->val('.add_assembly_item_input' , '')
 395     ->run('kivi.Part.focus_last_assembly_input')
 396     ->html('#items_sellprice_sum', $::form->format_amount(\%::myconfig, $items_sellprice_sum, 2, 0))
 397     ->html('#items_lastcost_sum' , $::form->format_amount(\%::myconfig, $items_lastcost_sum , 2, 0))
 398     ->html('#items_sum_diff',      $::form->format_amount(\%::myconfig, $items_sum_diff     , 2, 0))
 399     ->html('#items_sellprice_sum_basic', $::form->format_amount(\%::myconfig, $items_sellprice_sum, 2, 0))
 400     ->html('#items_lastcost_sum_basic' , $::form->format_amount(\%::myconfig, $items_lastcost_sum , 2, 0))
 401     ->render;
 402 }
 403
 404 sub action_show_multi_items_dialog {
 405   $_[0]->render('part/_multi_items_dialog', { layout => 0 },
 406     all_partsgroups => SL::DB::Manager::PartsGroup->get_all
 407   );
 408 }
 409
 410 sub action_multi_items_update_result {
 411   my $max_count = 100;
 412
 413   $::form->{multi_items}->{filter}->{obsolete} = 0;
 414
 415   my $count = $_[0]->multi_items_models->count;
 416
 417   if ($count == 0) {
 418     my $text = escape($::locale->text('No results.'));
 419     $_[0]->render($text, { layout => 0 });
 420   } elsif ($count > $max_count) {
 421     my $text = escpae($::locale->text('Too many results (#1 from #2).', $count, $max_count));
 422     $_[0]->render($text, { layout => 0 });
 423   } else {
 424     my $multi_items = $_[0]->multi_items_models->get;
 425     $_[0]->render('part/_multi_items_result', { layout => 0 },
 426                   multi_items => $multi_items);
 427   }
 428 }
 429
 430 sub action_add_makemodel_row {
 431   my ($self) = @_;
 432
 433   my $vendor_id = $::form->{add_makemodel};
 434
 435   my $vendor = SL::DB::Manager::Vendor->find_by(id => $vendor_id) or
 436     return $self->js->error(t8("No vendor selected or found!"))->render;
 437
 438   if ( grep { $vendor_id == $_->make } @{ $self->makemodels } ) {
 439     $self->js->flash('info', t8("This vendor has already been added."));
 440   };
 441
 442   my $position = scalar @{$self->makemodels} + 1;
 443
 444   my $mm = SL::DB::MakeModel->new(# parts_id    => $::form->{part}->{id},
 445                                   make        => $vendor->id,
 446                                   model       => '',
 447                                   lastcost    => 0,
 448                                   sortorder    => $position,
 449                                  ) or die "Can't create MakeModel object";
 450
 451   my $row_as_html = $self->p->render('part/_makemodel_row',
 452                                      makemodel => $mm,
 453                                      listrow   => $position % 2 ? 0 : 1,
 454   );
 455
 456   # after selection focus on the model field in the row that was just added
 457   $self->js
 458     ->append('#makemodel_rows', $row_as_html)  # append in tbody
 459     ->val('.add_makemodel_input', '')
 460     ->run('kivi.Part.focus_last_makemodel_input')
 461     ->render;
 462 }
 463
 464 sub action_add_customerprice_row {
 465   my ($self) = @_;
 466
 467   my $customer_id = $::form->{add_customerprice};
 468
 469   my $customer = SL::DB::Manager::Customer->find_by(id => $customer_id)
 470     or return $self->js->error(t8("No customer selected or found!"))->render;
 471
 472   if (grep { $customer_id == $_->customer_id } @{ $self->customerprices }) {
 473     $self->js->flash('info', t8("This customer has already been added."));
 474   }
 475
 476   my $position = scalar @{ $self->customerprices } + 1;
 477
 478   my $cu = SL::DB::PartCustomerPrice->new(
 479                       customer_id         => $customer->id,
 480                       customer_partnumber => '',
 481                       price               => 0,
 482                       sortorder           => $position,
 483   ) or die "Can't create Customerprice object";
 484
 485   my $row_as_html = $self->p->render(
 486                                      'part/_customerprice_row',
 487                                       customerprice => $cu,
 488                                       listrow       => $position % 2 ? 0
 489                                                                      : 1,
 490   );
 491
 492   $self->js->append('#customerprice_rows', $row_as_html)    # append in tbody
 493            ->val('.add_customerprice_input', '')
 494            ->run('kivi.Part.focus_last_customerprice_input')->render;
 495 }
 496
 497 sub action_reorder_items {
 498   my ($self) = @_;
 499
 500   my $part_type = $::form->{part_type};
 501
 502   my %sort_keys = (
 503     partnumber  => sub { $_[0]->part->partnumber },
 504     description => sub { $_[0]->part->description },
 505     qty         => sub { $_[0]->qty },
 506     sellprice   => sub { $_[0]->part->sellprice },
 507     lastcost    => sub { $_[0]->part->lastcost },
 508     partsgroup  => sub { $_[0]->part->partsgroup_id ? $_[0]->part->partsgroup->partsgroup : '' },
 509   );
 510
 511   my $method = $sort_keys{$::form->{order_by}};
 512
 513   my @items;
 514   if ($part_type eq 'assortment') {
 515     @items = @{ $self->assortment_items };
 516   } else {
 517     @items = @{ $self->assembly_items };
 518   };
 519
 520   my @to_sort = map { { old_pos => $_->position, order_by => $method->($_) } } @items;
 521   if ($::form->{order_by} =~ /^(qty|sellprice|lastcost)$/) {
 522     if ($::form->{sort_dir}) {
 523       @to_sort = sort { $a->{order_by} <=> $b->{order_by} } @to_sort;
 524     } else {
 525       @to_sort = sort { $b->{order_by} <=> $a->{order_by} } @to_sort;
 526     }
 527   } else {
 528     if ($::form->{sort_dir}) {
 529       @to_sort = sort { $a->{order_by} cmp $b->{order_by} } @to_sort;
 530     } else {
 531       @to_sort = sort { $b->{order_by} cmp $a->{order_by} } @to_sort;
 532     }
 533   };
 534
 535   $self->js->run('kivi.Part.redisplay_items', \@to_sort)->render;
 536 }
 537
 538 sub action_warehouse_changed {
 539   my ($self) = @_;
 540
 541   if ($::form->{warehouse_id} ) {
 542     $self->warehouse(SL::DB::Manager::Warehouse->find_by_or_create(id => $::form->{warehouse_id}));
 543     die unless ref($self->warehouse) eq 'SL::DB::Warehouse';
 544
 545     if ( $self->warehouse->id and @{$self->warehouse->bins} ) {
 546       $self->bin($self->warehouse->bins->[0]);
 547       $self->js
 548         ->html('#bin', $self->build_bin_select)
 549         ->focus('#part_bin_id');
 550       return $self->js->render;
 551     }
 552   }
 553
 554   # no warehouse was selected, empty the bin field and reset the id
 555   $self->js
 556        ->val('#part_bin_id', undef)
 557        ->html('#bin', '');
 558
 559   return $self->js->render;
 560 }
 561
 562 sub action_ajax_autocomplete {
 563   my ($self, %params) = @_;
 564
 565   # if someone types something, and hits enter, assume he entered the full name.
 566   # if something matches, treat that as sole match
 567   # since we need a second get models instance with different filters for that,
 568   # we only modify the original filter temporarily in place
 569   if ($::form->{prefer_exact}) {
 570     local $::form->{filter}{'all::ilike'} = delete local $::form->{filter}{'all:substr:multi::ilike'};
 571
 572     my $exact_models = SL::Controller::Helper::GetModels->new(
 573       controller   => $self,
 574       sorted       => 0,
 575       paginated    => { per_page => 2 },
 576       with_objects => [ qw(unit_obj classification) ],
 577     );
 578     my $exact_matches;
 579     if (1 == scalar @{ $exact_matches = $exact_models->get }) {
 580       $self->parts($exact_matches);
 581     }
 582   }
 583
 584   my @hashes = map {
 585    +{
 586      value       => $_->displayable_name,
 587      label       => $_->displayable_name,
 588      id          => $_->id,
 589      partnumber  => $_->partnumber,
 590      description => $_->description,
 591      ean         => $_->ean,
 592      part_type   => $_->part_type,
 593      unit        => $_->unit,
 594      cvars       => { map { ($_->config->name => { value => $_->value_as_text, is_valid => $_->is_valid }) } @{ $_->cvars_by_config } },
 595     }
 596   } @{ $self->parts }; # neato: if exact match triggers we don't even need the init_parts
 597
 598   $self->render(\ SL::JSON::to_json(\@hashes), { layout => 0, type => 'json', process => 0 });
 599 }
 600
 601 sub action_test_page {
 602   $_[0]->render('part/test_page', pre_filled_part => SL::DB::Manager::Part->get_first);
 603 }
 604
 605 sub action_part_picker_search {
 606   $_[0]->render('part/part_picker_search', { layout => 0 });
 607 }
 608
 609 sub action_part_picker_result {
 610   $_[0]->render('part/_part_picker_result', { layout => 0 }, parts => $_[0]->parts);
 611 }
 612
 613 sub action_show {
 614   my ($self) = @_;
 615
 616   if ($::request->type eq 'json') {
 617     my $part_hash;
 618     if (!$self->part) {
 619       # TODO error
 620     } else {
 621       $part_hash          = $self->part->as_tree;
 622       $part_hash->{cvars} = $self->part->cvar_as_hashref;
 623     }
 624
 625     $self->render(\ SL::JSON::to_json($part_hash), { layout => 0, type => 'json', process => 0 });
 626   }
 627 }
 628
 629 # helper functions
 630 sub validate_add_items {
 631   scalar @{$::form->{add_items}};
 632 }
 633
 634 sub prepare_assortment_render_vars {
 635   my ($self) = @_;
 636
 637   my %vars = ( items_sellprice_sum => $self->part->items_sellprice_sum,
 638                items_lastcost_sum  => $self->part->items_lastcost_sum,
 639                assortment_html     => $self->render_assortment_items_to_html( \@{$self->part->items} ),
 640              );
 641   $vars{items_sum_diff} = $vars{items_sellprice_sum} - $vars{items_lastcost_sum};
 642
 643   return \%vars;
 644 }
 645
 646 sub prepare_assembly_render_vars {
 647   my ($self) = @_;
 648
 649   croak("Need assembly item(s) to create a 'save as new' assembly.") unless $self->part->items;
 650
 651   my %vars = ( items_sellprice_sum => $self->part->items_sellprice_sum,
 652                items_lastcost_sum  => $self->part->items_lastcost_sum,
 653                assembly_html       => $self->render_assembly_items_to_html( \@{ $self->part->items } ),
 654              );
 655   $vars{items_sum_diff} = $vars{items_sellprice_sum} - $vars{items_lastcost_sum};
 656
 657   return \%vars;
 658 }
 659
 660 sub add {
 661   my ($self) = @_;
 662
 663   check_has_valid_part_type($self->part->part_type);
 664
 665   $self->_set_javascript;
 666   $self->_setup_form_action_bar;
 667
 668   my %title_hash = ( part       => t8('Add Part'),
 669                      assembly   => t8('Add Assembly'),
 670                      service    => t8('Add Service'),
 671                      assortment => t8('Add Assortment'),
 672                    );
 673
 674   $self->render(
 675     'part/form',
 676     title => $title_hash{$self->part->part_type},
 677   );
 678 }
 679
 680
 681 sub _set_javascript {
 682   my ($self) = @_;
 683   $::request->layout->use_javascript("${_}.js")  for qw(kivi.Part kivi.File kivi.PriceRule ckeditor/ckeditor ckeditor/adapters/jquery kivi.ShopPart);
 684   $::request->layout->add_javascripts_inline("\$(function(){kivi.PriceRule.load_price_rules_for_part(@{[ $self->part->id ]})});") if $self->part->id;
 685 }
 686
 687 sub recalc_item_totals {
 688   my ($self, %params) = @_;
 689
 690   if ( $params{part_type} eq 'assortment' ) {
 691     return 0 unless scalar @{$self->assortment_items};
 692   } elsif ( $params{part_type} eq 'assembly' ) {
 693     return 0 unless scalar @{$self->assembly_items};
 694   } else {
 695     carp "can only calculate sum for assortments and assemblies";
 696   };
 697
 698   my $part = SL::DB::Part->new(part_type => $params{part_type});
 699   if ( $part->is_assortment ) {
 700     $part->assortment_items( @{$self->assortment_items} );
 701     if ( $params{price_type} eq 'lastcost' ) {
 702       return $part->items_lastcost_sum;
 703     } else {
 704       if ( $params{pricegroup_id} ) {
 705         return $part->items_sellprice_sum(pricegroup_id => $params{pricegroup_id});
 706       } else {
 707         return $part->items_sellprice_sum;
 708       };
 709     }
 710   } elsif ( $part->is_assembly ) {
 711     $part->assemblies( @{$self->assembly_items} );
 712     if ( $params{price_type} eq 'lastcost' ) {
 713       return $part->items_lastcost_sum;
 714     } else {
 715       return $part->items_sellprice_sum;
 716     }
 717   }
 718 }
 719
 720 sub check_part_not_modified {
 721   my ($self) = @_;
 722
 723   return !($::form->{last_modification} && ($self->part->last_modification ne $::form->{last_modification}));
 724
 725 }
 726
 727 sub parse_form {
 728   my ($self) = @_;
 729
 730   my $is_new = !$self->part->id;
 731
 732   my $params = delete($::form->{part}) || { };
 733
 734   delete $params->{id};
 735   $self->part->assign_attributes(%{ $params});
 736   $self->part->bin_id(undef) unless $self->part->warehouse_id;
 737
 738   # Only reset items ([]) and rewrite from form if $::form->{assortment_items} isn't empty. This
 739   # will be the case for used assortments when saving, or when a used assortment
 740   # is "used as new"
 741   if ( $self->part->is_assortment and $::form->{assortment_items} and scalar @{$::form->{assortment_items}}) {
 742     $self->part->assortment_items([]);
 743     $self->part->add_assortment_items(@{$self->assortment_items}); # assortment_items has a get_set_init
 744   };
 745
 746   if ( $self->part->is_assembly and $::form->{assembly_items} and @{$::form->{assembly_items}} ) {
 747     $self->part->assemblies([]); # completely rewrite assortments each time
 748     $self->part->add_assemblies( @{ $self->assembly_items } );
 749   };
 750
 751   $self->part->translations([]);
 752   $self->parse_form_translations;
 753
 754   $self->part->prices([]);
 755   $self->parse_form_prices;
 756
 757   $self->parse_form_customerprices;
 758   $self->parse_form_makemodels;
 759 }
 760
 761 sub parse_form_prices {
 762   my ($self) = @_;
 763   # only save prices > 0
 764   my $prices = delete($::form->{prices}) || [];
 765   foreach my $price ( @{$prices} ) {
 766     my $sellprice = $::form->parse_amount(\%::myconfig, $price->{price});
 767     next unless $sellprice > 0; # skip negative prices as well
 768     my $p = SL::DB::Price->new(parts_id      => $self->part->id,
 769                                pricegroup_id => $price->{pricegroup_id},
 770                                price         => $sellprice,
 771                               );
 772     $self->part->add_prices($p);
 773   };
 774 }
 775
 776 sub parse_form_translations {
 777   my ($self) = @_;
 778   # don't add empty translations
 779   my $translations = delete($::form->{translations}) || [];
 780   foreach my $translation ( @{$translations} ) {
 781     next unless $translation->{translation};
 782     my $t = SL::DB::Translation->new( %{$translation} ) or die "Can't create translation";
 783     $self->part->add_translations( $translation );
 784   };
 785 }
 786
 787 sub parse_form_makemodels {
 788   my ($self) = @_;
 789
 790   my $makemodels_map;
 791   if ( $self->part->makemodels ) { # check for new parts or parts without makemodels
 792     $makemodels_map = { map { $_->id => Rose::DB::Object::Helpers::clone($_) } @{$self->part->makemodels} };
 793   };
 794
 795   $self->part->makemodels([]);
 796
 797   my $position = 0;
 798   my $makemodels = delete($::form->{makemodels}) || [];
 799   foreach my $makemodel ( @{$makemodels} ) {
 800     next unless $makemodel->{make};
 801     $position++;
 802     my $vendor = SL::DB::Manager::Vendor->find_by(id => $makemodel->{make}) || die "Can't find vendor from make";
 803
 804     my $id = $makemodels_map->{$makemodel->{id}} ? $makemodels_map->{$makemodel->{id}}->id : undef;
 805     my $mm = SL::DB::MakeModel->new( # parts_id   => $self->part->id, # will be assigned by row add_makemodels
 806                                      id         => $id,
 807                                      make       => $makemodel->{make},
 808                                      model      => $makemodel->{model} || '',
 809                                      lastcost   => $::form->parse_amount(\%::myconfig, $makemodel->{lastcost_as_number}),
 810                                      sortorder  => $position,
 811                                    );
 812     if ($makemodels_map->{$mm->id} && !$makemodels_map->{$mm->id}->lastupdate && $makemodels_map->{$mm->id}->lastcost == 0 && $mm->lastcost == 0) {
 813       # lastupdate isn't set, original lastcost is 0 and new lastcost is 0
 814       # don't change lastupdate
 815     } elsif ( !$makemodels_map->{$mm->id} && $mm->lastcost == 0 ) {
 816       # new makemodel, no lastcost entered, leave lastupdate empty
 817     } elsif ($makemodels_map->{$mm->id} && $makemodels_map->{$mm->id}->lastcost == $mm->lastcost) {
 818       # lastcost hasn't changed, use original lastupdate
 819       $mm->lastupdate($makemodels_map->{$mm->id}->lastupdate);
 820     } else {
 821       $mm->lastupdate(DateTime->now);
 822     };
 823     $self->part->makemodel( scalar @{$self->part->makemodels} ? 1 : 0 ); # do we need this boolean anymore?
 824     $self->part->add_makemodels($mm);
 825   };
 826 }
 827
 828 sub parse_form_customerprices {
 829   my ($self) = @_;
 830
 831   my $customerprices_map;
 832   if ( $self->part->customerprices ) { # check for new parts or parts without customerprices
 833     $customerprices_map = { map { $_->id => Rose::DB::Object::Helpers::clone($_) } @{$self->part->customerprices} };
 834   };
 835
 836   $self->part->customerprices([]);
 837
 838   my $position = 0;
 839   my $customerprices = delete($::form->{customerprices}) || [];
 840   foreach my $customerprice ( @{$customerprices} ) {
 841     next unless $customerprice->{customer_id};
 842     $position++;
 843     my $customer = SL::DB::Manager::Customer->find_by(id => $customerprice->{customer_id}) || die "Can't find customer from id";
 844
 845     my $id = $customerprices_map->{$customerprice->{id}} ? $customerprices_map->{$customerprice->{id}}->id : undef;
 846     my $cu = SL::DB::PartCustomerPrice->new( # parts_id   => $self->part->id, # will be assigned by row add_customerprices
 847                                      id                   => $id,
 848                                      customer_id          => $customerprice->{customer_id},
 849                                      customer_partnumber  => $customerprice->{customer_partnumber} || '',
 850                                      price                => $::form->parse_amount(\%::myconfig, $customerprice->{price_as_number}),
 851                                      sortorder            => $position,
 852                                    );
 853     if ($customerprices_map->{$cu->id} && !$customerprices_map->{$cu->id}->lastupdate && $customerprices_map->{$cu->id}->price == 0 && $cu->price == 0) {
 854       # lastupdate isn't set, original price is 0 and new lastcost is 0
 855       # don't change lastupdate
 856     } elsif ( !$customerprices_map->{$cu->id} && $cu->price == 0 ) {
 857       # new customerprice, no lastcost entered, leave lastupdate empty
 858     } elsif ($customerprices_map->{$cu->id} && $customerprices_map->{$cu->id}->price == $cu->price) {
 859       # price hasn't changed, use original lastupdate
 860       $cu->lastupdate($customerprices_map->{$cu->id}->lastupdate);
 861     } else {
 862       $cu->lastupdate(DateTime->now);
 863     };
 864     $self->part->add_customerprices($cu);
 865   };
 866 }
 867
 868 sub build_bin_select {
 869   select_tag('part.bin_id', [ $_[0]->warehouse->bins ],
 870     title_key => 'description',
 871     default   => $_[0]->bin->id,
 872   );
 873 }
 874
 875
 876 # get_set_inits for partpicker
 877
 878 sub init_parts {
 879   if ($::form->{no_paginate}) {
 880     $_[0]->models->disable_plugin('paginated');
 881   }
 882
 883   $_[0]->models->get;
 884 }
 885
 886 # get_set_inits for part controller
 887 sub init_part {
 888   my ($self) = @_;
 889
 890   # used by edit, save, delete and add
 891
 892   if ( $::form->{part}{id} ) {
 893     return SL::DB::Part->new(id => $::form->{part}{id})->load(with => [ qw(makemodels customerprices prices translations partsgroup shop_parts shop_parts.shop) ]);
 894   } else {
 895     die "part_type missing" unless $::form->{part}{part_type};
 896     return SL::DB::Part->new(part_type => $::form->{part}{part_type});
 897   };
 898 }
 899
 900 sub init_orphaned {
 901   my ($self) = @_;
 902   return $self->part->orphaned;
 903 }
 904
 905 sub init_models {
 906   my ($self) = @_;
 907
 908   SL::Controller::Helper::GetModels->new(
 909     controller => $self,
 910     sorted => {
 911       _default  => {
 912         by => 'partnumber',
 913         dir  => 1,
 914       },
 915       partnumber  => t8('Partnumber'),
 916       description  => t8('Description'),
 917     },
 918     with_objects => [ qw(unit_obj classification) ],
 919   );
 920 }
 921
 922 sub init_p {
 923   SL::Presenter->get;
 924 }
 925
 926
 927 sub init_assortment_items {
 928   # this init is used while saving and whenever assortments change dynamically
 929   my ($self) = @_;
 930   my $position = 0;
 931   my @array;
 932   my $assortment_items = delete($::form->{assortment_items}) || [];
 933   foreach my $assortment_item ( @{$assortment_items} ) {
 934     next unless $assortment_item->{parts_id};
 935     $position++;
 936     my $part = SL::DB::Manager::Part->find_by(id => $assortment_item->{parts_id}) || die "Can't determine item to be added";
 937     my $ai = SL::DB::AssortmentItem->new( parts_id      => $part->id,
 938                                           qty           => $::form->parse_amount(\%::myconfig, $assortment_item->{qty_as_number}),
 939                                           charge        => $assortment_item->{charge},
 940                                           unit          => $assortment_item->{unit} || $part->unit,
 941                                           position      => $position,
 942     );
 943
 944     push(@array, $ai);
 945   };
 946   return \@array;
 947 }
 948
 949 sub init_makemodels {
 950   my ($self) = @_;
 951
 952   my $position = 0;
 953   my @makemodel_array = ();
 954   my $makemodels = delete($::form->{makemodels}) || [];
 955
 956   foreach my $makemodel ( @{$makemodels} ) {
 957     next unless $makemodel->{make};
 958     $position++;
 959     my $mm = SL::DB::MakeModel->new( # parts_id   => $self->part->id, # will be assigned by row add_makemodels
 960                                     id        => $makemodel->{id},
 961                                     make      => $makemodel->{make},
 962                                     model     => $makemodel->{model} || '',
 963                                     lastcost  => $::form->parse_amount(\%::myconfig, $makemodel->{lastcost_as_number} || 0),
 964                                     sortorder => $position,
 965                                   ) or die "Can't create mm";
 966     # $mm->id($makemodel->{id}) if $makemodel->{id};
 967     push(@makemodel_array, $mm);
 968   };
 969   return \@makemodel_array;
 970 }
 971
 972 sub init_customerprices {
 973   my ($self) = @_;
 974
 975   my $position = 0;
 976   my @customerprice_array = ();
 977   my $customerprices = delete($::form->{customerprices}) || [];
 978
 979   foreach my $customerprice ( @{$customerprices} ) {
 980     next unless $customerprice->{customer_id};
 981     $position++;
 982     my $cu = SL::DB::PartCustomerPrice->new( # parts_id   => $self->part->id, # will be assigned by row add_customerprices
 983                                     id                  => $customerprice->{id},
 984                                     customer_partnumber => $customerprice->{customer_partnumber},
 985                                     customer_id         => $customerprice->{customer_id} || '',
 986                                     price               => $::form->parse_amount(\%::myconfig, $customerprice->{price_as_number} || 0),
 987                                     sortorder           => $position,
 988                                   ) or die "Can't create cu";
 989     # $cu->id($customerprice->{id}) if $customerprice->{id};
 990     push(@customerprice_array, $cu);
 991   };
 992   return \@customerprice_array;
 993 }
 994
 995 sub init_assembly_items {
 996   my ($self) = @_;
 997   my $position = 0;
 998   my @array;
 999   my $assembly_items = delete($::form->{assembly_items}) || [];
1000   foreach my $assembly_item ( @{$assembly_items} ) {
1001     next unless $assembly_item->{parts_id};
1002     $position++;
1003     my $part = SL::DB::Manager::Part->find_by(id => $assembly_item->{parts_id}) || die "Can't determine item to be added";
1004     my $ai = SL::DB::Assembly->new(parts_id    => $part->id,
1005                                    bom         => $assembly_item->{bom},
1006                                    qty         => $::form->parse_amount(\%::myconfig, $assembly_item->{qty_as_number}),
1007                                    position    => $position,
1008                                   );
1009     push(@array, $ai);
1010   };
1011   return \@array;
1012 }
1013
1014 sub init_all_warehouses {
1015   my ($self) = @_;
1016   SL::DB::Manager::Warehouse->get_all(query => [ or => [ invalid => 0, invalid => undef, id => $self->part->warehouse_id ] ]);
1017 }
1018
1019 sub init_all_languages {
1020   SL::DB::Manager::Language->get_all_sorted;
1021 }
1022
1023 sub init_all_partsgroups {
1024   my ($self) = @_;
1025   SL::DB::Manager::PartsGroup->get_all_sorted(query => [ or => [ id => $self->part->partsgroup_id, obsolete => 0 ] ]);
1026 }
1027
1028 sub init_all_buchungsgruppen {
1029   my ($self) = @_;
1030   if ( $self->part->orphaned ) {
1031     return SL::DB::Manager::Buchungsgruppe->get_all_sorted;
1032   } else {
1033     return SL::DB::Manager::Buchungsgruppe->get_all_sorted(where => [ id => $self->part->buchungsgruppen_id ]);
1034   }
1035 }
1036
1037 sub init_shops_not_assigned {
1038   my ($self) = @_;
1039
1040   my @used_shop_ids = map { $_->shop->id } @{ $self->part->shop_parts };
1041   if ( @used_shop_ids ) {
1042     return SL::DB::Manager::Shop->get_all( query => [ obsolete => 0, '!id' => \@used_shop_ids ], sort_by => 'sortkey' );
1043   }
1044   else {
1045     return SL::DB::Manager::Shop->get_all( query => [ obsolete => 0 ], sort_by => 'sortkey' );
1046   }
1047 }
1048
1049 sub init_all_units {
1050   my ($self) = @_;
1051   if ( $self->part->orphaned ) {
1052     return SL::DB::Manager::Unit->get_all_sorted;
1053   } else {
1054     return SL::DB::Manager::Unit->get_all(where => [ unit => $self->part->unit ]);
1055   }
1056 }
1057
1058 sub init_all_payment_terms {
1059   my ($self) = @_;
1060   SL::DB::Manager::PaymentTerm->get_all_sorted(query => [ or => [ id => $self->part->payment_id, obsolete => 0 ] ]);
1061 }
1062
1063 sub init_all_price_factors {
1064   SL::DB::Manager::PriceFactor->get_all_sorted;
1065 }
1066
1067 sub init_all_pricegroups {
1068   SL::DB::Manager::Pricegroup->get_all_sorted;
1069 }
1070
1071 # model used to filter/display the parts in the multi-items dialog
1072 sub init_multi_items_models {
1073   SL::Controller::Helper::GetModels->new(
1074     controller     => $_[0],
1075     model          => 'Part',
1076     with_objects   => [ qw(unit_obj partsgroup classification) ],
1077     disable_plugin => 'paginated',
1078     source         => $::form->{multi_items},
1079     sorted         => {
1080       _default    => {
1081         by  => 'partnumber',
1082         dir => 1,
1083       },
1084       partnumber  => t8('Partnumber'),
1085       description => t8('Description')}
1086   );
1087 }
1088
1089 sub init_parts_classification_filter {
1090   return [] unless $::form->{parts_classification_type};
1091
1092   return [ used_for_sale     => 't' ] if $::form->{parts_classification_type} eq 'sales';
1093   return [ used_for_purchase => 't' ] if $::form->{parts_classification_type} eq 'purchases';
1094
1095   die "no query rules for parts_classification_type " . $::form->{parts_classification_type};
1096 }
1097
1098 # simple checks to run on $::form before saving
1099
1100 sub form_check_part_description_exists {
1101   my ($self) = @_;
1102
1103   return 1 if $::form->{part}{description};
1104
1105   $self->js->flash('error', t8('Part Description missing!'))
1106            ->run('kivi.Part.set_tab_active_by_name', 'basic_data')
1107            ->focus('#part_description');
1108   return 0;
1109 }
1110
1111 sub form_check_assortment_items_exist {
1112   my ($self) = @_;
1113
1114   return 1 unless $::form->{part}{part_type} eq 'assortment';
1115   # skip item check for existing assortments that have been used
1116   return 1 if ($self->part->id and !$self->part->orphaned);
1117
1118   # new or orphaned parts must have items in $::form->{assortment_items}
1119   unless ( $::form->{assortment_items} and scalar @{$::form->{assortment_items}} ) {
1120     $self->js->run('kivi.Part.set_tab_active_by_name', 'assortment_tab')
1121              ->focus('#add_assortment_item_name')
1122              ->flash('error', t8('The assortment doesn\'t have any items.'));
1123     return 0;
1124   };
1125   return 1;
1126 }
1127
1128 sub form_check_assortment_items_unique {
1129   my ($self) = @_;
1130
1131   return 1 unless $::form->{part}{part_type} eq 'assortment';
1132
1133   my %duplicate_elements;
1134   my %count;
1135   for (map { $_->{parts_id} } @{$::form->{assortment_items}}) {
1136     $duplicate_elements{$_}++ if $count{$_}++;
1137   };
1138
1139   if ( keys %duplicate_elements ) {
1140     $self->js->run('kivi.Part.set_tab_active_by_name', 'assortment_tab')
1141              ->flash('error', t8('There are duplicate assortment items'));
1142     return 0;
1143   };
1144   return 1;
1145 }
1146
1147 sub form_check_assembly_items_exist {
1148   my ($self) = @_;
1149
1150   return 1 unless $::form->{part}->{part_type} eq 'assembly';
1151
1152   # skip item check for existing assembly that have been used
1153   return 1 if ($self->part->id and !$self->part->orphaned);
1154
1155   unless ( $::form->{assembly_items} and scalar @{$::form->{assembly_items}} ) {
1156     $self->js->run('kivi.Part.set_tab_active_by_name', 'assembly_tab')
1157              ->focus('#add_assembly_item_name')
1158              ->flash('error', t8('The assembly doesn\'t have any items.'));
1159     return 0;
1160   };
1161   return 1;
1162 }
1163
1164 sub form_check_partnumber_is_unique {
1165   my ($self) = @_;
1166
1167   if ( !$::form->{part}{id} and $::form->{part}{partnumber} ) {
1168     my $count = SL::DB::Manager::Part->get_all_count(where => [ partnumber => $::form->{part}{partnumber} ]);
1169     if ( $count ) {
1170       $self->js->flash('error', t8('The partnumber already exists!'))
1171                ->focus('#part_description');
1172       return 0;
1173     };
1174   };
1175   return 1;
1176 }
1177
1178 # general checking functions
1179
1180 sub check_part_id {
1181   die t8("Can't load item without a valid part.id") . "\n" unless $::form->{part}{id};
1182 }
1183
1184 sub check_form {
1185   my ($self) = @_;
1186
1187   $self->form_check_part_description_exists || return 0;
1188   $self->form_check_assortment_items_exist  || return 0;
1189   $self->form_check_assortment_items_unique || return 0;
1190   $self->form_check_assembly_items_exist    || return 0;
1191   $self->form_check_partnumber_is_unique    || return 0;
1192
1193   return 1;
1194 }
1195
1196 sub check_has_valid_part_type {
1197   die "invalid part_type" unless $_[0] =~ /^(part|service|assembly|assortment)$/;
1198 }
1199
1200
1201 sub normalize_text_blocks {
1202   my ($self) = @_;
1203
1204   # check if feature is enabled (select normalize_part_descriptions from defaults)
1205   return unless ($::instance_conf->get_normalize_part_descriptions);
1206
1207   # text block
1208   foreach (qw(description)) {
1209     $self->part->{$_} =~ s/\s+$//s;
1210     $self->part->{$_} =~ s/^\s+//s;
1211     $self->part->{$_} =~ s/ {2,}/ /g;
1212   }
1213   # html block (caveat: can be circumvented by using bold or italics)
1214   $self->part->{notes} =~ s/^<p>(&nbsp;)+\s+/<p>/s;
1215   $self->part->{notes} =~ s/(&nbsp;)+<\/p>$/<\/p>/s;
1216
1217 }
1218
1219 sub render_assortment_items_to_html {
1220   my ($self, $assortment_items, $number_of_items) = @_;
1221
1222   my $position = $number_of_items + 1;
1223   my $html;
1224   foreach my $ai (@$assortment_items) {
1225     $html .= $self->p->render('part/_assortment_row',
1226                               PART     => $self->part,
1227                               orphaned => $self->orphaned,
1228                               ITEM     => $ai,
1229                               listrow  => $position % 2 ? 1 : 0,
1230                               position => $position, # for legacy assemblies
1231                              );
1232     $position++;
1233   };
1234   return $html;
1235 }
1236
1237 sub render_assembly_items_to_html {
1238   my ($self, $assembly_items, $number_of_items) = @_;
1239
1240   my $position = $number_of_items + 1;
1241   my $html;
1242   foreach my $ai (@{$assembly_items}) {
1243     $html .= $self->p->render('part/_assembly_row',
1244                               PART     => $self->part,
1245                               orphaned => $self->orphaned,
1246                               ITEM     => $ai,
1247                               listrow  => $position % 2 ? 1 : 0,
1248                               position => $position, # for legacy assemblies
1249                              );
1250     $position++;
1251   };
1252   return $html;
1253 }
1254
1255 sub parse_add_items_to_objects {
1256   my ($self, %params) = @_;
1257   my $part_type = $params{part_type};
1258   die unless $params{part_type} =~ /^(assortment|assembly)$/;
1259   my $position = $params{position} || 1;
1260
1261   my @add_items = grep { $_->{qty_as_number} } @{ $::form->{add_items} };
1262
1263   my @item_objects;
1264   foreach my $item ( @add_items ) {
1265     my $part = SL::DB::Manager::Part->find_by(id => $item->{parts_id}) || die "Can't load part";
1266     my $ai;
1267     if ( $part_type eq 'assortment' ) {
1268        $ai = SL::DB::AssortmentItem->new(part          => $part,
1269                                          qty           => $::form->parse_amount(\%::myconfig, $item->{qty_as_number}),
1270                                          unit          => $part->unit, # TODO: $item->{unit} || $part->unit
1271                                          position      => $position,
1272                                         ) or die "Can't create AssortmentItem from item";
1273     } elsif ( $part_type eq 'assembly' ) {
1274       $ai = SL::DB::Assembly->new(parts_id    => $part->id,
1275                                  # id          => $self->assembly->id, # will be set on save
1276                                  qty         => $::form->parse_amount(\%::myconfig, $item->{qty_as_number}),
1277                                  bom         => 0, # default when adding: no bom
1278                                  position    => $position,
1279                                 );
1280     } else {
1281       die "part_type must be assortment or assembly";
1282     }
1283     push(@item_objects, $ai);
1284     $position++;
1285   };
1286
1287   return \@item_objects;
1288 }
1289
1290 sub _setup_form_action_bar {
1291   my ($self) = @_;
1292
1293   my $may_edit           = $::auth->assert('part_service_assembly_edit', 'may fail');
1294   my $used_in_pricerules = !!SL::DB::Manager::PriceRuleItem->get_all_count(where => [type => 'part', value_int => $self->part->id]);
1295
1296   for my $bar ($::request->layout->get('actionbar')) {
1297     $bar->add(
1298       combobox => [
1299         action => [
1300           t8('Save'),
1301           call      => [ 'kivi.Part.save' ],
1302           disabled  => !$may_edit ? t8('You do not have the permissions to access this function.') : undef,
1303         ],
1304         action => [
1305           t8('Use as new'),
1306           call     => [ 'kivi.Part.use_as_new' ],
1307           disabled => !$self->part->id ? t8('The object has not been saved yet.')
1308                     : !$may_edit       ? t8('You do not have the permissions to access this function.')
1309                     :                    undef,
1310         ],
1311       ], # end of combobox "Save"
1312
1313       action => [
1314         t8('Delete'),
1315         call     => [ 'kivi.Part.delete' ],
1316         confirm  => t8('Do you really want to delete this object?'),
1317         disabled => !$self->part->id       ? t8('This object has not been saved yet.')
1318                   : !$may_edit             ? t8('You do not have the permissions to access this function.')
1319                   : !$self->part->orphaned ? t8('This object has already been used.')
1320                   : $used_in_pricerules    ? t8('This object is used in price rules.')
1321                   :                          undef,
1322       ],
1323
1324       'separator',
1325
1326       action => [
1327         t8('History'),
1328         call     => [ 'kivi.Part.open_history_popup' ],
1329         disabled => !$self->part->id ? t8('This object has not been saved yet.')
1330                   : !$may_edit       ? t8('You do not have the permissions to access this function.')
1331                   :                    undef,
1332       ],
1333     );
1334   }
1335 }
1336
1337 1;
1338
1339 __END__
1340
1341 =encoding utf-8
1342
1343 =head1 NAME
1344
1345 SL::Controller::Part - Part CRUD controller
1346
1347 =head1 DESCRIPTION
1348
1349 Controller for adding/editing/saving/deleting parts.
1350
1351 All the relations are loaded at once and saving the part, adding a history
1352 entry and saving CVars happens inside one transaction.  When saving the old
1353 relations are deleted and written as new to the database.
1354
1355 Relations for parts:
1356
1357 =over 2
1358
1359 =item makemodels
1360
1361 =item translations
1362
1363 =item assembly items
1364
1365 =item assortment items
1366
1367 =item prices
1368
1369 =back
1370
1371 =head1 PART_TYPES
1372
1373 There are 4 different part types:
1374
1375 =over 4
1376
1377 =item C<part>
1378
1379 The "default" part type.
1380
1381 inventory_accno_id is set.
1382
1383 =item C<service>
1384
1385 Services can't be stocked.
1386
1387 inventory_accno_id isn't set.
1388
1389 =item C<assembly>
1390
1391 Assemblies consist of other parts, services, assemblies or assortments. They
1392 aren't meant to be bought, only sold. To add assemblies to stock you typically
1393 have to make them, which reduces the stock by its respective components. Once
1394 an assembly item has been created there is currently no way to "disassemble" it
1395 again. An assembly item can appear several times in one assembly. An assmbly is
1396 sold as one item with a defined sellprice and lastcost. If the component prices
1397 change the assortment price remains the same. The assembly items may be printed
1398 in a record if the item's "bom" is set.
1399
1400 =item C<assortment>
1401
1402 Similar to assembly, but each assortment item may only appear once per
1403 assortment. When selling an assortment the assortment items are added to the
1404 record together with the assortment, which is added with sellprice 0.
1405
1406 Technically an assortment doesn't have a sellprice, but rather the sellprice is
1407 determined by the sum of the current assortment item prices when the assortment
1408 is added to a record. This also means that price rules and customer discounts
1409 will be applied to the assortment items.
1410
1411 Once the assortment items have been added they may be modified or deleted, just
1412 as if they had been added manually, the individual assortment items aren't
1413 linked to the assortment or the other assortment items in any way.
1414
1415 =back
1416
1417 =head1 URL ACTIONS
1418
1419 =over 4
1420
1421 =item C<action_add_part>
1422
1423 =item C<action_add_service>
1424
1425 =item C<action_add_assembly>
1426
1427 =item C<action_add_assortment>
1428
1429 =item C<action_add PART_TYPE>
1430
1431 An alternative to the action_add_$PART_TYPE actions, takes the mandatory
1432 parameter part_type as an action. Example:
1433
1434   controller.pl?action=Part/add&part_type=service
1435
1436 =item C<action_add_from_record>
1437
1438 When adding new items to records they can be created on the fly if the entered
1439 partnumber or description doesn't exist yet. After being asked what part type
1440 the new item should have the user is redirected to the correct edit page.
1441
1442 Depending on whether the item was added from a sales or a purchase record, only
1443 the relevant part classifications should be selectable for new item, so this
1444 parameter is passed on via a hidden parts_classification_type in the new_item
1445 template.
1446
1447 =item C<action_save>
1448
1449 Saves the current part and then reloads the edit page for the part.
1450
1451 =item C<action_use_as_new>
1452
1453 Takes the information from the current part, plus any modifications made on the
1454 page, and creates a new edit page that is ready to be saved. The partnumber is
1455 set empty, so a new partnumber from the number range will be used if the user
1456 doesn't enter one manually.
1457
1458 Unsaved changes to the original part aren't updated.
1459
1460 The part type cannot be changed in this way.
1461
1462 =item C<action_delete>
1463
1464 Deletes the current part and then redirects to the main page, there is no
1465 callback.
1466
1467 The delete button only appears if the part is 'orphaned', according to
1468 SL::DB::Part orphaned.
1469
1470 The part can't be deleted if it appears in invoices, orders, delivery orders,
1471 the inventory, or is part of an assembly or assortment.
1472
1473 If the part is deleted its relations prices, makdemodel, assembly,
1474 assortment_items and translation are are also deleted via DELETE ON CASCADE.
1475
1476 Before this controller items that appeared in inventory didn't count as
1477 orphaned and could be deleted and the inventory entries were also deleted, this
1478 "feature" hasn't been implemented.
1479
1480 =item C<action_edit part.id>
1481
1482 Load and display a part for editing.
1483
1484   controller.pl?action=Part/edit&part.id=12345
1485
1486 Passing the part id is mandatory, and the parameter is "part.id", not "id".
1487
1488 =back
1489
1490 =head1 BUTTON ACTIONS
1491
1492 =over 4
1493
1494 =item C<history>
1495
1496 Opens a popup displaying all the history entries. Once a new history controller
1497 is written the button could link there instead, with the part already selected.
1498
1499 =back
1500
1501 =head1 AJAX ACTIONS
1502
1503 =over 4
1504
1505 =item C<action_update_item_totals>
1506
1507 Is called whenever an element with the .recalc class loses focus, e.g. the qty
1508 amount of an item changes. The sum of all sellprices and lastcosts is
1509 calculated and the totals updated. Uses C<recalc_item_totals>.
1510
1511 =item C<action_add_assortment_item>
1512
1513 Adds a new assortment item from a part picker seleciton to the assortment item list
1514
1515 If the item already exists in the assortment the item isn't added and a Flash
1516 error shown.
1517
1518 Rather than running kivi.Part.renumber_positions and kivi.Part.assembly_recalc
1519 after adding each new item, add the new object to the item objects that were
1520 already parsed, calculate totals via a dummy part then update the row and the
1521 totals.
1522
1523 =item C<action_add_assembly_item>
1524
1525 Adds a new assembly item from a part picker seleciton to the assembly item list
1526
1527 If the item already exists in the assembly a flash info is generated, but the
1528 item is added.
1529
1530 Rather than running kivi.Part.renumber_positions and kivi.Part.assembly_recalc
1531 after adding each new item, add the new object to the item objects that were
1532 already parsed, calculate totals via a dummy part then update the row and the
1533 totals.
1534
1535 =item C<action_add_multi_assortment_items>
1536
1537 Parses the items to be added from the form generated by the multi input and
1538 appends the html of the tr-rows to the assortment item table. Afterwards all
1539 assortment items are renumbered and the sums recalculated via
1540 kivi.Part.renumber_positions and kivi.Part.assortment_recalc.
1541
1542 =item C<action_add_multi_assembly_items>
1543
1544 Parses the items to be added from the form generated by the multi input and
1545 appends the html of the tr-rows to the assembly item table. Afterwards all
1546 assembly items are renumbered and the sums recalculated via
1547 kivi.Part.renumber_positions and kivi.Part.assembly_recalc.
1548
1549 =item C<action_show_multi_items_dialog>
1550
1551 =item C<action_multi_items_update_result>
1552
1553 =item C<action_add_makemodel_row>
1554
1555 Add a new makemodel row with the vendor that was selected via the vendor
1556 picker.
1557
1558 Checks the already existing makemodels and warns if a row with that vendor
1559 already exists. Currently it is possible to have duplicate vendor rows.
1560
1561 =item C<action_reorder_items>
1562
1563 Sorts the item table for assembly or assortment items.
1564
1565 =item C<action_warehouse_changed>
1566
1567 =back
1568
1569 =head1 ACTIONS part picker
1570
1571 =over 4
1572
1573 =item C<action_ajax_autocomplete>
1574
1575 =item C<action_test_page>
1576
1577 =item C<action_part_picker_search>
1578
1579 =item C<action_part_picker_result>
1580
1581 =item C<action_show>
1582
1583 =back
1584
1585 =head1 FORM CHECKS
1586
1587 =over 2
1588
1589 =item C<check_form>
1590
1591 Calls some simple checks that test the submitted $::form for obvious errors.
1592 Return 1 if all the tests were successfull, 0 as soon as one test fails.
1593
1594 Errors from the failed tests are stored as ClientJS actions in $self->js. In
1595 some cases extra actions are taken, e.g. if the part description is missing the
1596 basic data tab is selected and the description input field is focussed.
1597
1598 =back
1599
1600 =over 4
1601
1602 =item C<form_check_part_description_exists>
1603
1604 =item C<form_check_assortment_items_exist>
1605
1606 =item C<form_check_assortment_items_unique>
1607
1608 =item C<form_check_assembly_items_exist>
1609
1610 =item C<form_check_partnumber_is_unique>
1611
1612 =back
1613
1614 =head1 HELPER FUNCTIONS
1615
1616 =over 4
1617
1618 =item C<parse_form>
1619
1620 When submitting the form for saving, parses the transmitted form. Expects the
1621 following data:
1622
1623  $::form->{part}
1624  $::form->{makemodels}
1625  $::form->{translations}
1626  $::form->{prices}
1627  $::form->{assemblies}
1628  $::form->{assortments}
1629
1630 CVar data is currently stored directly in $::form, e.g. $::form->{cvar_size}.
1631
1632 =item C<recalc_item_totals %params>
1633
1634 Helper function for calculating the total lastcost and sellprice for assemblies
1635 or assortments according to their items, which are parsed from the current
1636 $::form.
1637
1638 Is called whenever the qty of an item is changed or items are deleted.
1639
1640 Takes two params:
1641
1642 * part_type : 'assortment' or 'assembly' (mandatory)
1643
1644 * price_type: 'lastcost' or 'sellprice', default is 'sellprice'
1645
1646 Depending on the price_type the lastcost sum or sellprice sum is returned.
1647
1648 Doesn't work for recursive items.
1649
1650 =back
1651
1652 =head1 GET SET INITS
1653
1654 There are get_set_inits for
1655
1656 * assembly items
1657
1658 * assortment items
1659
1660 * makemodels
1661
1662 which parse $::form and automatically create an array of objects.
1663
1664 These inits are used during saving and each time a new element is added.
1665
1666 =over 4
1667
1668 =item C<init_makemodels>
1669
1670 Parses $::form->{makemodels}, creates an array of makemodel objects and stores them in
1671 $self->part->makemodels, ready to be saved.
1672
1673 Used for saving parts and adding new makemodel rows.
1674
1675 =item C<parse_add_items_to_objects PART_TYPE>
1676
1677 Parses the resulting form from either the part-picker submit or the multi-item
1678 submit, and creates an arrayref of assortment_item or assembly objects, that
1679 can be rendered via C<render_assortment_items_to_html> or
1680 C<render_assembly_items_to_html>.
1681
1682 Mandatory param: part_type: assortment or assembly (the resulting html will differ)
1683 Optional param: position (used for numbering and listrow class)
1684
1685 =item C<render_assortment_items_to_html ITEM_OBJECTS>
1686
1687 Takes an array_ref of assortment_items, and generates tables rows ready for
1688 adding to the assortment table.  Is used when a part is loaded, or whenever new
1689 assortment items are added.
1690
1691 =item C<parse_form_makemodels>
1692
1693 Makemodels can't just be overwritten, because of the field "lastupdate", that
1694 remembers when the lastcost for that vendor changed the last time.
1695
1696 So the original values are cloned and remembered, so we can compare if lastcost
1697 was changed in $::form, and keep or update lastupdate.
1698
1699 lastcost isn't updated until the first time it was saved with a value, until
1700 then it is empty.
1701
1702 Also a boolean "makemodel" needs to be written in parts, depending on whether
1703 makemodel entries exist or not.
1704
1705 We still need init_makemodels for when we open the part for editing.
1706
1707 =back
1708
1709 =head1 TODO
1710
1711 =over 4
1712
1713 =item *
1714
1715 It should be possible to jump to the edit page in a specific tab
1716
1717 =item *
1718
1719 Support callbacks, e.g. creating a new part from within an order, and jumping
1720 back to the order again afterwards.
1721
1722 =item *
1723
1724 Support units when adding assembly items or assortment items. Currently the
1725 default unit of the item is always used.
1726
1727 =item *
1728
1729 Calculate sellprice and lastcost totals recursively, in case e.g. an assembly
1730 consists of other assemblies.
1731
1732 =back
1733
1734 =head1 AUTHOR
1735
1736 G. Richardson E<lt>grichardson@kivitendo-premium.deE<gt>
1737
1738 =cut