projekt kivitendo

package SL::DB::Manager::Piece;

use strict;

use base qw(SL::DB::Helper::Manager);

sub object_class { 'SL::DB::Piece' }

__PACKAGE__->make_manager_methods;

1;

# This file has been auto-generated. Do not modify it; it will be overwritten

# by rose_auto_create_model.pl automatically.

package SL::DB::Piece;

use strict;

use parent qw(SL::DB::Object);

__PACKAGE__->meta->table('pieces');

__PACKAGE__->meta->columns(

  batch_id           => { type => 'integer' },

  bin_id             => { type => 'integer' },

  deleted            => { type => 'boolean', not_null => 1, default => 'false' },

  delivery_in_id     => { type => 'integer' },

  delivery_out_id    => { type => 'integer' },

  employee_id        => { type => 'integer' },

  id                 => { type => 'integer', not_null => 1, sequence => 'id' },

  itime              => { type => 'timestamp', not_null => 1, default => 'now()' },

  mtime              => { type => 'timestamp' },

  notes              => { type => 'text' },

  serialnumber       => { type => 'text', not_null => 1 },

  part_id            => { type => 'integer', not_null => 1 },

  producer_id        => { type => 'integer', not_null => 1 },

  weight             => { type => 'numeric', precision => 15, scale => 5 },

);

__PACKAGE__->meta->primary_key_columns([ 'id' ]);

__PACKAGE__->meta->add_unique_key( Rose::DB::Object::Metadata::UniqueKey->new(

  columns => [ 'producer_id', 'part_id', 'batch_id', 'serialnumber' ]

));

__PACKAGE__->meta->allow_inline_column_values(1);

__PACKAGE__->meta->foreign_keys(

  bin           => {

    class       => 'SL::DB::Bin',

    key_columns => { bin_id => 'id' },

  },

  batch         => {

    class       => 'SL::DB::Batch',

    key_columns => { batch_id => 'id' },

  },

  delivery_in => {

    class       => 'SL::DB::DeliveryOrder',

    key_columns => { delivery_in_id => 'id' },

  },

  delivery_out => {

    class       => 'SL::DB::DeliveryOrder',

    key_columns => { delivery_out_id => 'id' },

  },

  employee => {

    class       => 'SL::DB::Employee',

    key_columns => { employee_id => 'id' },

  },

  part => {

    class       => 'SL::DB::Part',

    key_columns => { part_id => 'id' },

  },

  producer => {

    class       => 'SL::DB::Vendor',

    key_columns => { producer_id => 'id' },

  },

);

1;

;

package SL::DB::Piece;

use strict;

use SL::DB::MetaSetup::Piece;

use SL::DB::Manager::Piece;

__PACKAGE__->meta->initialize;

__PACKAGE__->before_save('_before_save_set_serialnumber');

sub _before_save_set_serialnumber {

  my $self = shift;

  $self->create_trans_number if !$self->serialnumber;

  return 1;

}

sub displayable_name {

  my $self = shift;

  return $self->batch_id

    ? join '/', grep $_, $self->producer->displayable_name, $self->part->displayable_name, $self->batch->batchnumber, $self->serialnumber

    : join '/', grep $_, $self->producer->displayable_name, $self->part->displayable_name, $self->serialnumber

  ;

}

sub last_modification {

  my ($self) = @_;

  return $self->mtime // $self->itime;

}

sub validate {

  my( $self, $locale ) = ( shift, $::locale );

  my @errors = ();

  $self->producer_id  || push @errors, $locale->text( 'The producer is missing.' );

  $self->part_id      || push @errors, $locale->text( 'The part is missing.' );

  $self->serialnumber || push @errors, $locale->text( 'The serial number is missing.' );

  scalar @errors && return @errors;

  SL::DB::Manager::Vendor->get_all_count( where => [ id => $self->producer_id ] ) || push @errors, $locale->text( "This producer dosn't exist." );

  SL::DB::Manager::Part->get_all_count( where => [ id => $self->part_id ] )       || push @errors, $locale->text( "This part dosn't exist."     );

  if( $self->batch_id ) {

    SL::DB::Manager::Batch->get_all_count( where => [ id => $self->batch_id ] )   || push @errors, $locale->text( "This batch dosn't exist."     );

    SL::DB::Manager::Batch->get_all_count( where => [

        id           => $self->batch_id,

        producer_id  => $self->producer_id,

        part_id      => $self->part_id

      ]

    ) || push @errors, $locale->text( "This producer/part/batch doesn't exist." );

  }

  scalar @errors && return @errors;

  unless( $self->id ) {

    unless( $self->batch_id ) {

      SL::DB::Manager::Piece->get_all_count(

        where => [

          producer_id  => $self->producer_id,

          part_id      => $self->part_id,

          serialnumber => $self->serialnumber

        ]

      ) && push @errors, $locale->text( 'This producer/part/batch/serial number already does exist.' );

    } else {

      SL::DB::Manager::Piece->get_all_count(

        where => [

          producer_id  => $self->producer_id,

          part_id      => $self->part_id,

          batch_id     => $self->batch_id,

          serialnumber => $self->serialnumber

        ]

      ) && push @errors, $locale->text( 'This producer/part/batch/serial number already does exist.' );

    }

  } else {

    unless( $self->batch_id ) {

      SL::DB::Manager::Piece->get_all_count(

        where => [

          id           => { ne => $self->id },

          producer_id  => $self->producer_id,

          part_id      => $self->part_id,

          serialnumber => $self->serialnumber

        ]

      ) && push @errors, $locale->text( 'This producer/part/batch/serial number already does exist.' );

    } else {

      SL::DB::Manager::Piece->get_all_count(

        where => [

          id           => { ne => $self->id },

          producer_id  => $self->producer_id,

          part_id      => $self->part_id,

          batch_id     => $self->batch_id,

          serialnumber => $self->serialnumber

        ]

      ) && push @errors, $locale->text( 'This producer/part/batch/serial number already does exist.' );

    }

  }

  return @errors;

}

sub undefine {

  my $self = shift;

  $self->batch_id || $self->batch_id( undef );

  $self->weight || $self->weight( undef );

  $self->delivery_in_id || $self->delivery_in_id( undef );

  $self->bin_id || $self->bin_id( undef );

  $self->delivery_out_id || $self->delivery_out_id( undef );

}

1;

__END__

=pod

=encoding utf-8

=head1 NAME

SL::DB::Piece: Model for the table 'pieces'

=head1 SYNOPSIS

This is a standard Rose::DB::Object based model and can be used as one.

=head1 TYPES

None

=head1 FUNCTIONS

=over 4

=item C<displayable_name>

Returns the composed unique name to display.

=item C<last_modification>

Returns the datetime of the last modification.

=item C<undefine>

Sets the empty strings of numeric fields to undefine.

=item C<validate>

Returns the error messages if this batch doesn,t fullfill the constrains.

=back

=head1 AUTHORS

Rolf Flühmann E<lt>rolf.fluehmann@revamp-it.chE<gt>,

ROlf Flühmann E<lt>rolf_fluehmann@gmx.chE<gt>

=cut

-- @tag: create_pieces

-- @description: neue Tabelle für Exemplare einer Produktionseinheit

-- @depends: release_3_5_0 defaults_add_feature_production create_batches

CREATE TABLE pieces (

  id              SERIAL               PRIMARY KEY,

  itime           TIMESTAMP            NOT NULL DEFAULT now(),

  mtime           TIMESTAMP,

  deleted         BOOLEAN              NOT NULL DEFAULT FALSE,

  serialnumber    TEXT                 NOT NULL,

  weight          REAL,

  notes           TEXT,

  producer_id     integer NOT NULL REFERENCES vendor          (id) ON DELETE RESTRICT,

  part_id         integer NOT NULL REFERENCES parts           (id) ON DELETE RESTRICT,

  batch_id        integer          REFERENCES batches         (id) ON DELETE RESTRICT,

  delivery_in_id  integer          REFERENCES delivery_orders (id) ON DELETE RESTRICT,

  delivery_out_id integer          REFERENCES delivery_orders (id) ON DELETE RESTRICT,

  bin_id          integer          REFERENCES bin             (id) ON DELETE RESTRICT,

  employee_id     integer          REFERENCES employee        (id) ON DELETE SET NULL,

  UNIQUE (producer_id, part_id, batch_id, serialnumber)

);

CREATE TRIGGER mtime_pieces BEFORE UPDATE ON pieces FOR EACH ROW EXECUTE PROCEDURE set_mtime();