projekt kivitendo

package SL::DB::Batch;

use strict;

use SL::DB::MetaSetup::Batch;

use SL::DB::Manager::Batch;

__PACKAGE__->meta->initialize;

__PACKAGE__->before_save('_before_save_set_batchnumber');

sub _before_save_set_batchnumber {

  my $self = shift;

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

  return 1;

}

sub displayable_name {

  my $self = shift;

  return join '/', grep $_, $self->producer->displayable_name, $self->part->displayable_name, $self->batchnumber ;

}

sub has_children {

  my $self = shift;

  $self->id && eval "require SL::DB::Piece" && return SL::DB::Manager::Piece->get_all_count( where => [ batch_id => $self->id ] );

  return 1;

}

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->batchnumber || push @errors, $locale->text( 'The batchnumber is missing.' );

  $self->batchdate   || push @errors, $locale->text( 'The batchdate 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."     );

  scalar @errors && return @errors;

  unless( $self->id ) {

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

      where => [

        producer_id => $self->producer_id,

        part_id     => $self->part_id,

        batchnumber => $self->batchnumber

      ]

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

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

      where => [

        producer_id => $self->producer_id,

        part_id     => $self->part_id,

        batchdate   => $self->batchdate,

        location    => $self->location,

        process     => $self->process

      ]

    ) && push @errors, $locale->text( 'This producer/part/patchdate/location/process already does exist.' );

  } else {

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

      where => [

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

        producer_id => $self->producer_id,

        part_id     => $self->part_id,

        batchnumber => $self->batchnumber

      ]

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

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

      where => [

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

        producer_id => $self->producer_id,

        part_id     => $self->part_id,

        batchdate   => $self->batchdate,

        location    => $self->location,

        process     => $self->process

      ]

    ) && push @errors, $locale->text( 'This producer/part/batchdate/location/process already does exist.' );

  }

  return @errors;

}

1;

__END__

=pod

=encoding utf-8

=head1 NAME

SL::DB::Batch: Model for the table 'batches'

=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<has_children>

Returns 0 if there aren't any referenes from other tables.

=item C<last_modification>

Returns the datetime of the last modification.

=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

package SL::DB::Manager::Batch;

use strict;

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

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

__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::Batch;

use strict;

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

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

__PACKAGE__->meta->columns(

  batchdate          => { type => 'date', not_null => 1, default => 'now()' },

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

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

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

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

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

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

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

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

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

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

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

);

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

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

  columns => [ 'producer_id', 'part_id', 'batchnumber' ]

));

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

  columns => [ 'producer_id', 'part_id', 'batchdate', 'location', 'process' ]

));

__PACKAGE__->meta->allow_inline_column_values(1);

__PACKAGE__->meta->foreign_keys(

  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;

;

-- @tag: create_batches

-- @description: neue Tabelle für Produktionseinheiten

-- @depends: release_3_5_0 defaults_add_feature_production

CREATE TABLE batches (

  id             SERIAL               PRIMARY KEY,

  itime          TIMESTAMP            NOT NULL DEFAULT now(),

  mtime          TIMESTAMP,

  deleted        BOOLEAN              NOT NULL DEFAULT FALSE,

  batchnumber    TEXT                 NOT NULL,

  batchdate      DATE                 NOT NULL DEFAULT ('now'::text)::date,

  location       TEXT,

  process        TEXT,

  notes          TEXT,

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

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

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

  UNIQUE (producer_id, part_id, batchnumber),

  UNIQUE (producer_id, part_id, batchdate, location, process)

);

CREATE TRIGGER mtime_batches BEFORE UPDATE ON batches FOR EACH ROW EXECUTE PROCEDURE set_mtime();