Transports/Model/Transport.pm

use strict;
use warnings;

package Transports::Model::Transport::Schema;
use Jifty::DBI::Schema;

# Your column definitions go here.  See L<Jifty::DBI::Schema> for
# documentation about how to write column definitions.

column date => 
        type is 'timestamp',
        label is 'Date',
        is immutable,
        render_as 'unrendered',
        default is 'now()',
        since '0.0.1';

column source =>
        refers_to Transports::Model::Source,
        label is 'Source client',
#       render_as 'Combobox',
#       sort_order is 'name',
#       render_as 'select',
        is mandatory,
        since '0.0.6';

column destination =>
        refers_to Transports::Model::Destination,
        label is 'Destionation client',
        is mandatory,
        since '0.0.7';

column request_nr =>
        type is 'text',
        label is 'Change request nr',
        is mandatory,
        since '0.0.7';

column client_dependent =>
        type is 'boolean',
        label 'Client dependent',
        is mandatory,
        since '0.0.7',

column created_by =>
        refers_to Transports::Model::User,
        label is 'Request by',
        since '0.0.7';
        

package Transports::Model::Transport;
use base qw/Transports::Record/;
use Transports::Model::Source;
use Transports::Model::Destination;
use Transports::Model::User;

# Your model-specific methods go here.

=head2 create

Create new transport and fill in C<created_by>.

=cut

sub create {
        my $self = shift;
        my %args = (@_);

        my $user = $self->current_user ? $self->current_user->user_object : undef;

        return unless ($user);

#       my $now  = DateTime->now();
#       $args{'updated'} = $now->ymd . " " . $now->hms;
        $args{'created_by'} = $user;
        my ($id) = $self->SUPER::create(%args);
        return ($id);
}

=head2 current_user_can ACTION

Let everybody create, read and update, but not delete.

=cut

sub current_user_can {
    my $self = shift;
    my $type = shift;

    # We probably want something like this eventually:
    if ($type =~ /(?:create|read|update)/i) {
        return 1;
    } else {
        return $self->SUPER::current_user_can($type, @_);
    }
}


1;

1	use strict;
2	use warnings;
3
4	package Transports::Model::Transport::Schema;
5	use Jifty::DBI::Schema;
6
7	# Your column definitions go here. See L<Jifty::DBI::Schema> for
8	# documentation about how to write column definitions.
9
10	column date =>
11	type is 'timestamp',
12	label is 'Date',
13	is immutable,
14	render_as 'unrendered',
15	default is 'now()',
16	since '0.0.1';
17
18	column source =>
19	refers_to Transports::Model::Source,
20	label is 'Source client',
21	# render_as 'Combobox',
22	# sort_order is 'name',
23	# render_as 'select',
24	is mandatory,
25	since '0.0.6';
26
27	column destination =>
28	refers_to Transports::Model::Destination,
29	label is 'Destionation client',
30	is mandatory,
31	since '0.0.7';
32
33	column request_nr =>
34	type is 'text',
35	label is 'Change request nr',
36	is mandatory,
37	since '0.0.7';
38
39	column client_dependent =>
40	type is 'boolean',
41	label 'Client dependent',
42	is mandatory,
43	since '0.0.7',
44
45	column created_by =>
46	refers_to Transports::Model::User,
47	label is 'Request by',
48	since '0.0.7';
49
50
51	package Transports::Model::Transport;
52	use base qw/Transports::Record/;
53	use Transports::Model::Source;
54	use Transports::Model::Destination;
55	use Transports::Model::User;
56
57	# Your model-specific methods go here.
58
59	=head2 create
60
61	Create new transport and fill in C<created_by>.
62
63	=cut
64
65	sub create {
66	my $self = shift;
67	my %args = (@_);
68
69	my $user = $self->current_user ? $self->current_user->user_object : undef;
70
71	return unless ($user);
72
73	# my $now = DateTime->now();
74	# $args{'updated'} = $now->ymd . " " . $now->hms;
75	$args{'created_by'} = $user;
76	my ($id) = $self->SUPER::create(%args);
77	return ($id);
78	}
79
80	=head2 current_user_can ACTION
81
82	Let everybody create, read and update, but not delete.
83
84	=cut
85
86	sub current_user_can {
87	my $self = shift;
88	my $type = shift;
89
90	# We probably want something like this eventually:
91	if ($type =~ /(?:create\|read\|update)/i) {
92	return 1;
93	} else {
94	return $self->SUPER::current_user_can($type, @_);
95	}
96	}
97
98
99	1;
100