Arh/View/UnitPictures.pm

package Arh::View::UnitPictures;

use strict;
use warnings;

use base 'Jifty::View::Declare::CRUD';
use Jifty::View::Declare -base;

use Data::Dump qw/dump/;

sub object_type { 'Picture' };

private template search_region => sub {};
private template 'no_items_found' => sub {};

sub display_columns {
        my $self = shift;
        return ('picture');
}

sub edit_columns {
        my $self = shift;
        return ('picture');
}

template 'list' => sub {
    my $self = shift;

    my ( $page, $unit ) = get(qw(page unit));
    my $item_path = $self->fragment_for("view");
        my $fragment_for_new_picture = $self->fragment_for('new_picture');
    my $collection =  $self->_current_collection();
        # XXX show just pictures from current unit
        $collection->limit( column => 'unit', value => $unit ) if $unit;

        warn "## list page: $page unit: $unit fragment_for_new_picture: $fragment_for_new_picture item_path: $item_path";

    div {
                { class is 'pictures' }; 

                show('./search_region');
                show( './paging_top',    $collection, $page );
                show( './list_items',    $collection, $item_path );
                show( './paging_bottom', $collection, $page );

                render_region(
                        name => 'new_picture',
                        path => $fragment_for_new_picture,
                        defaults => {
                                object_type => $self->object_type,
                                unit => $unit,
                        },
                );
        }

};

template 'view' => sub :CRUDView {
        my $self   = shift;
        my ( $id, $unit ) = get(qw(id unit));
        my $record = $self->_get_record( $id );

        my $delete = $record->as_delete_action(
                moniker => "delete-" . Jifty->web->serial,
        );

        warn "## view id: $id unit $unit";

        form {
                img { attr { src => "/static/pics/thumb/" . $record->thumbnail } }
                tt { $record->filename }
                span { $record->type->name };

                if ( $record->current_user_can('delete') && $self->current_user->editing ) {
                        outs_raw( $delete->button(
                                label   => _("Delete picture"),
                                class   => "float-crud-button button-delete",
                                onclick => {
                                        submit => $delete,
                                        confirm => _('Really delete?'),
                                        replace_with => '/__jifty/empty',
                                        refresh_self => 1,
                                        args => { id => $id },
                                },
                        ));
                };
        }; 

};

template 'new_picture' => sub {
    my $self = shift;
        return unless $self->current_user->editing;

        my ( $id, $unit ) = get(qw(id unit));
        warn "## new_picture id: $id unit: $unit";

        my $record_class = $self->record_class;
        warn "## new_picture record_class: $record_class\n";
#       my $create = $record_class->as_create_action(
        my $create = new_action(
                class => 'UploadPicture',
                moniker => "create-" . Jifty->web->serial,
        );

        my $attach_to =
                Jifty->web->current_region->parent ?
                Jifty->web->current_region->parent->get_element( 'div.list' ) :
                Jifty->web->current_region;

        warn "## attach_to = $attach_to";

    form {
                render_action( $create => [ 'campaign', 'content', 'type' ] );
                outs_raw( $create->hidden( unit => $unit ) );
                hyperlink(
                        label   => _("Add picture"),
                        class   => "float-crud-button button-add",
                        onclick => [
                                {
                                        submit => $create,
                                },
                                {       refresh_self => 1       },
                                {
                                        element => $attach_to,
                                        append => $self->fragment_for('view'),
                                        args => {
                                                object_type => $self->object_type,
                                                id => { result_of => $create, name => 'id' },
                                                unit => $unit,
                                        },
                                },
                        ],
                        as_button => 1,
                );
    };
};

template 'fragment' => sub {
        my ( $self, $unit ) = @_;

        #warn "## unit = ", dump( $unit );

        my $unitpictures = Arh::Model::PictureCollection->new;
        $unitpictures->limit( column => 'unit', value => $unit->id );
        warn "## ", $unitpictures->count, " pictures for unit ",$unit->id;

        div {
                { class is 'pictures-by-unit' };

                if ( $unitpictures->count ) {
                        em { _('Pictures for unit'), ' ', $unit->name };

                } else {
                        em { _('No pictures for unit'), ' ', $unit->name };
                }

                set( search_collection => $unitpictures );

                render_region(
                        name => 'unit-pictures',
                        path => '/unitpictures/list',
                        defaults => {
                                page => 1,
                                unit => $unit->id,
                        }
                );

        }
};

1;
1	dpavlin	28	package Arh::View::UnitPictures;
2
3			use strict;
4			use warnings;
5
6			use base 'Jifty::View::Declare::CRUD';
7			use Jifty::View::Declare -base;
8
9			use Data::Dump qw/dump/;
10
11	dpavlin	50	sub object_type { 'Picture' };
12	dpavlin	28
13			private template search_region => sub {};
14			private template 'no_items_found' => sub {};
15
16			sub display_columns {
17			my $self = shift;
18			return ('picture');
19			}
20
21			sub edit_columns {
22			my $self = shift;
23			return ('picture');
24			}
25
26			template 'list' => sub {
27			my $self = shift;
28
29			my ( $page, $unit ) = get(qw(page unit));
30			my $item_path = $self->fragment_for("view");
31			my $fragment_for_new_picture = $self->fragment_for('new_picture');
32			my $collection = $self->_current_collection();
33			# XXX show just pictures from current unit
34			$collection->limit( column => 'unit', value => $unit ) if $unit;
35	dpavlin	53
36			warn "## list page: $page unit: $unit fragment_for_new_picture: $fragment_for_new_picture item_path: $item_path";
37
38	dpavlin	28	div {
39			{ class is 'pictures' };
40
41			show('./search_region');
42			show( './paging_top', $collection, $page );
43			show( './list_items', $collection, $item_path );
44			show( './paging_bottom', $collection, $page );
45
46			render_region(
47			name => 'new_picture',
48			path => $fragment_for_new_picture,
49			defaults => {
50			object_type => $self->object_type,
51			unit => $unit,
52			},
53			);
54			}
55
56			};
57
58			template 'view' => sub :CRUDView {
59			my $self = shift;
60			my ( $id, $unit ) = get(qw(id unit));
61			my $record = $self->_get_record( $id );
62
63			my $delete = $record->as_delete_action(
64			moniker => "delete-" . Jifty->web->serial,
65			);
66
67	dpavlin	53	warn "## view id: $id unit $unit";
68	dpavlin	28
69			form {
70	dpavlin	61	img { attr { src => "/static/pics/thumb/" . $record->thumbnail } }
71	dpavlin	53	tt { $record->filename }
72			span { $record->type->name };
73
74	dpavlin	28	if ( $record->current_user_can('delete') && $self->current_user->editing ) {
75	dpavlin	29	outs_raw( $delete->button(
76	dpavlin	28	label => _("Delete picture"),
77			class => "float-crud-button button-delete",
78			onclick => {
79			submit => $delete,
80			confirm => _('Really delete?'),
81			replace_with => '/__jifty/empty',
82			refresh_self => 1,
83			args => { id => $id },
84			},
85	dpavlin	29	));
86	dpavlin	28	};
87			};
88
89			};
90
91			template 'new_picture' => sub {
92			my $self = shift;
93			return unless $self->current_user->editing;
94
95			my ( $id, $unit ) = get(qw(id unit));
96	dpavlin	50	warn "## new_picture id: $id unit: $unit";
97	dpavlin	44
98	dpavlin	50	my $record_class = $self->record_class;
99			warn "## new_picture record_class: $record_class\n";
100	dpavlin	53	# my $create = $record_class->as_create_action(
101			my $create = new_action(
102			class => 'UploadPicture',
103	dpavlin	28	moniker => "create-" . Jifty->web->serial,
104			);
105
106			my $attach_to =
107	dpavlin	61	Jifty->web->current_region->parent ?
108			Jifty->web->current_region->parent->get_element( 'div.list' ) :
109			Jifty->web->current_region;
110	dpavlin	28
111			warn "## attach_to = $attach_to";
112
113			form {
114	dpavlin	44	render_action( $create => [ 'campaign', 'content', 'type' ] );
115	dpavlin	53	outs_raw( $create->hidden( unit => $unit ) );
116	dpavlin	28	hyperlink(
117			label => _("Add picture"),
118			class => "float-crud-button button-add",
119			onclick => [
120			{
121			submit => $create,
122			},
123			{ refresh_self => 1 },
124			{
125			element => $attach_to,
126			append => $self->fragment_for('view'),
127			args => {
128			object_type => $self->object_type,
129			id => { result_of => $create, name => 'id' },
130			unit => $unit,
131			},
132			},
133			],
134			as_button => 1,
135			);
136			};
137			};
138
139			template 'fragment' => sub {
140			my ( $self, $unit ) = @_;
141
142	dpavlin	30	#warn "## unit = ", dump( $unit );
143	dpavlin	28
144	dpavlin	50	my $unitpictures = Arh::Model::PictureCollection->new;
145	dpavlin	28	$unitpictures->limit( column => 'unit', value => $unit->id );
146			warn "## ", $unitpictures->count, " pictures for unit ",$unit->id;
147
148			div {
149			{ class is 'pictures-by-unit' };
150
151	dpavlin	33	if ( $unitpictures->count ) {
152			em { _('Pictures for unit'), ' ', $unit->name };
153	dpavlin	50
154	dpavlin	33	} else {
155			em { _('No pictures for unit'), ' ', $unit->name };
156	dpavlin	36	}
157	dpavlin	33
158	dpavlin	54	set( search_collection => $unitpictures );
159
160			render_region(
161			name => 'unit-pictures',
162			path => '/unitpictures/list',
163			defaults => {
164			page => 1,
165			unit => $unit->id,
166			}
167			);
168
169	dpavlin	28	}
170			};
171
172			1;