Arh/View/Units.pm

package Arh::View::Units;

use strict;
use warnings;

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

use Data::Dump qw/dump/;

sub object_type { 'Unit' };

sub per_page {
        my $per_page = get('per_page') || 5;
        warn "## Units per_page = $per_page\n";
        return $per_page;
};

sub display_columns {
        my $self = shift;
        return ( qw/
                unit_id
                name
                subcategory
                category
                site
                gps
                placement
                context
                discovery
                function
                reusage
                ownership
                presevation_place
                inventory_nr
                dimensions
                condition
                toplogy
                technique
                description
                construction
                iconography
                decoration
                motifs
                inscription
                language
                font
                author
                chronology
                chronostyle
                explored
                conservations
                restorations
                legal
                links
                sources
                bibliography
                copyright
                material
        / );
}

#private template search_region => sub {};

=for later

template 'index.html' => page {
        my $self = shift;
        title is $self->object_type;
        form {
                render_region(
                        name     => $self->object_type.'-list',
                        path     => $self->fragment_base_path.'/list'
                );
        };
};

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

        my ( $page ) = get('page');

        my $item_path = get('item_path') || $self->fragment_for("view");
        my $collection =  $self->_current_collection();

        if ( $self->per_page == 1 ) {
                warn "## bulk import get to last page\n";
                $page = $collection->pager->last_page;
        }

        div {
                {class is 'crud-'.$self->object_type};

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

                show( './new_item_region');
        }

};

=cut

private template 'paging_top' => sub {
        my $self           = shift;
        my $collection = shift;
        my $page           = shift || 1;
                                          
        if ( $collection->pager->last_page > 1 ) {
                span {
                        { class is 'page-count' };
                        outs(
                                _( "Found %1 units, showing %2-%3 on page %4/%5",
                                        $collection->pager->total_entries,
                                        $collection->pager->first,
                                        $collection->pager->last,
                                        $page,
                                        $collection->pager->last_page
                                )
                        );
                }
        }
        show( './paging_bottom', $collection, $page );
};


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

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

        my $delete = $record->as_delete_action(
                moniker => "delete-" . Jifty->web->serial,
        );
        my $editing = $record->current_user_can('write');
        warn "## current_user_can('write') = $editing\n";
        $editing = 0 unless $self->current_user->editing;
        warn "## editing ",$editing ? 'ok' : 'DENIED';

        div { { class is 'unit' }

                if ( $editing ) {
                        outs_raw($delete->button(
                                label => _('Delete unit'),
                                class => 'float-crud-button button-delete',
                                onclick => {
                                        submit => $delete,
                                        confirm => _('Really delete?'),
#                                       region => Jifty->web->current_region,
                                        replace_with => '/__jifty/empty',
                                        refresh_self => 1,
                                        args => { id => $id },
                                },
                        ));
                };

                foreach my $f ( $self->display_columns ) {
                        if ( $f eq 'material' ) {
                                set( search_collection => $record->material );
                                render_region(
                                        name => 'unit-materials',
                                        path => '/materials/list',
                                        defaults => {
                                                page => 1,
                                                unit => $record->id,
                                        }
                                );
                        } else {
                                my %opt;
                                if ( ! $editing ) {
                                        $opt{render_mode} = 'read';
                                        # skip fields without values
                                        $opt{render_as} = 'hidden' if ! defined( $update->record->$f );
                                }
                                render_param( $update => $f, %opt );
                        }
                };
                if ( $editing ) {
                        div {
                                { class is 'submit_button' };
                                hyperlink(
                                        label => _('Update'),
                                        onclick => {
                                                submit => $update,
                                                refresh_self => 1,
                                        },
                                );
                        }
                }

        }; # div class unit

        show('/unitpictures/fragment', $record);

        hr {};
};

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

        my ( $object_type, $id ) = ( $self->object_type, get('id') );
        my $record_class = $self->record_class;
        my $create = $record_class->as_create_action;

        h1 { _("New unit") };

        div {

                foreach my $f ( $self->display_columns ) {
#                       last if $f eq 'material' && ! $id;
                        render_param( $create => $f ) unless $f eq 'material';
                        #warn "## $f";
                }

                div {
                        { class is 'submit_button' };
                        hyperlink(
                                label   => _("Add"),
                                onclick => [
                                        {
                                                submit => $create,
#                                               args => {
#                                               },
                                        },
                                        {       refresh_self => 1       },
                                        {
                                                element => Jifty->web->current_region->parent->get_element( 'div.list' ),
                                                append => $self->fragment_for('view'),
                                                args => {
                                                        object_type => $object_type,
                                                        id => { result_of => $create, name => 'id' },
                                                        unit => get('unit'),
                                                },
                                        },
                                ],
                                as_button => 1,
                        );
                };

        };
};

1;
1	dpavlin	15	package Arh::View::Units;
2
3			use strict;
4			use warnings;
5
6			use base 'Jifty::View::Declare::CRUD';
7			use Jifty::View::Declare -base;
8
9	dpavlin	58	use Data::Dump qw/dump/;
10
11	dpavlin	15	sub object_type { 'Unit' };
12
13	dpavlin	67	sub per_page {
14			my $per_page = get('per_page') \|\| 5;
15			warn "## Units per_page = $per_page\n";
16			return $per_page;
17			};
18	dpavlin	66
19	dpavlin	23	sub display_columns {
20			my $self = shift;
21	dpavlin	39	return ( qw/
22			unit_id
23			name
24			subcategory
25			category
26			site
27			gps
28			placement
29			context
30			discovery
31			function
32			reusage
33			ownership
34			presevation_place
35			inventory_nr
36			dimensions
37			condition
38			toplogy
39			technique
40			description
41	dpavlin	58	construction
42	dpavlin	39	iconography
43			decoration
44			motifs
45			inscription
46			language
47			font
48			author
49			chronology
50			chronostyle
51			explored
52			conservations
53			restorations
54			legal
55			links
56			sources
57			bibliography
58			copyright
59	dpavlin	63	material
60	dpavlin	39	/ );
61	dpavlin	23	}
62
63	dpavlin	15	#private template search_region => sub {};
64
65	dpavlin	67	=for later
66
67			template 'index.html' => page {
68			my $self = shift;
69			title is $self->object_type;
70			form {
71			render_region(
72			name => $self->object_type.'-list',
73			path => $self->fragment_base_path.'/list'
74			);
75			};
76			};
77
78			template 'list' => sub {
79			my $self = shift;
80
81			my ( $page ) = get('page');
82
83			my $item_path = get('item_path') \|\| $self->fragment_for("view");
84			my $collection = $self->_current_collection();
85
86			if ( $self->per_page == 1 ) {
87			warn "## bulk import get to last page\n";
88			$page = $collection->pager->last_page;
89			}
90
91			div {
92			{class is 'crud-'.$self->object_type};
93
94			show('./search_region');
95			show( './paging_top', $collection, $page );
96			show( './paging_bottom', $collection, $page );
97			show( './list_items', $collection, $item_path );
98			show( './paging_bottom', $collection, $page );
99
100			show( './new_item_region');
101			}
102
103			};
104
105			=cut
106
107	dpavlin	66	private template 'paging_top' => sub {
108			my $self = shift;
109			my $collection = shift;
110			my $page = shift \|\| 1;
111
112			if ( $collection->pager->last_page > 1 ) {
113			span {
114			{ class is 'page-count' };
115			outs(
116			_( "Found %1 units, showing %2-%3 on page %4/%5",
117			$collection->pager->total_entries,
118			$collection->pager->first,
119			$collection->pager->last,
120			$page,
121			$collection->pager->last_page
122			)
123			);
124	dpavlin	67	}
125	dpavlin	66	}
126	dpavlin	69	show( './paging_bottom', $collection, $page );
127	dpavlin	66	};
128
129
130	dpavlin	15	template 'view' => sub :CRUDView {
131			my $self = shift;
132	dpavlin	23	my $id = get('id');
133			my $record = $self->_get_record( $id );
134	dpavlin	15
135			my $update = $record->as_update_action(
136			moniker => "update-" . Jifty->web->serial,
137			);
138
139	dpavlin	23	my $delete = $record->as_delete_action(
140			moniker => "delete-" . Jifty->web->serial,
141			);
142			my $editing = $record->current_user_can('write');
143			warn "## current_user_can('write') = $editing\n";
144			$editing = 0 unless $self->current_user->editing;
145			warn "## editing ",$editing ? 'ok' : 'DENIED';
146	dpavlin	15
147	dpavlin	28	div { { class is 'unit' }
148	dpavlin	23
149	dpavlin	67	if ( $editing ) {
150	dpavlin	23	outs_raw($delete->button(
151	dpavlin	28	label => _('Delete unit'),
152			class => 'float-crud-button button-delete',
153	dpavlin	23	onclick => {
154			submit => $delete,
155			confirm => _('Really delete?'),
156			# region => Jifty->web->current_region,
157			replace_with => '/__jifty/empty',
158			refresh_self => 1,
159			args => { id => $id },
160			},
161			));
162			};
163
164			foreach my $f ( $self->display_columns ) {
165	dpavlin	15	if ( $f eq 'material' ) {
166			set( search_collection => $record->material );
167			render_region(
168			name => 'unit-materials',
169			path => '/materials/list',
170			defaults => {
171			page => 1,
172			unit => $record->id,
173			}
174			);
175			} else {
176			my %opt;
177	dpavlin	58	if ( ! $editing ) {
178			$opt{render_mode} = 'read';
179			# skip fields without values
180			$opt{render_as} = 'hidden' if ! defined( $update->record->$f );
181			}
182	dpavlin	15	render_param( $update => $f, %opt );
183			}
184			};
185	dpavlin	23	if ( $editing ) {
186	dpavlin	20	div {
187			{ class is 'submit_button' };
188			hyperlink(
189			label => _('Update'),
190			onclick => {
191			submit => $update,
192			refresh_self => 1,
193			},
194	dpavlin	67	);
195			}
196	dpavlin	20	}
197	dpavlin	28
198			}; # div class unit
199
200			show('/unitpictures/fragment', $record);
201
202	dpavlin	15	hr {};
203			};
204
205	dpavlin	23	template 'new_item' => sub {
206			my $self = shift;
207			return unless $self->current_user->editing;
208
209	dpavlin	66	my ( $object_type, $id ) = ( $self->object_type, get('id') );
210			my $record_class = $self->record_class;
211			my $create = $record_class->as_create_action;
212	dpavlin	23
213			h1 { _("New unit") };
214
215	dpavlin	67	div {
216	dpavlin	23
217			foreach my $f ( $self->display_columns ) {
218	dpavlin	39	# last if $f eq 'material' && ! $id;
219	dpavlin	63	render_param( $create => $f ) unless $f eq 'material';
220	dpavlin	42	#warn "## $f";
221	dpavlin	23	}
222
223			div {
224			{ class is 'submit_button' };
225			hyperlink(
226			label => _("Add"),
227			onclick => [
228			{
229			submit => $create,
230	dpavlin	39	# args => {
231			# },
232	dpavlin	23	},
233			{ refresh_self => 1 },
234			{
235			element => Jifty->web->current_region->parent->get_element( 'div.list' ),
236			append => $self->fragment_for('view'),
237			args => {
238			object_type => $object_type,
239			id => { result_of => $create, name => 'id' },
240			unit => get('unit'),
241			},
242			},
243			],
244			as_button => 1,
245			);
246	dpavlin	67	};
247	dpavlin	23
248			};
249			};
250
251	dpavlin	15	1;