A3C/View/Strix.pm

package A3C::View::Strix;

=head1 NAME

A3C::View::Strix

=head1 DESCRIPTION

Display information about Strix instances

=head1 TEMPLATES

=cut

use strict;
use warnings;

use Jifty::View::Declare -base;
use Data::Dump qw/dump/;

=head2 /

Display instaces search and some stats

=cut

template 'index.html' => page {

        title is _('Strix instances');

        my $orgs = A3C::Model::StrixInstanceCollection->new;
        $orgs->unlimit;

        div { _('Number of instances in Strix: %1', $orgs->count ) };

        render_region(
                name => 'selected-instances',
                path => '/strix/selected-instances'
        );

        render_region(
                name => 'search-instances',
                path => '/strix/search-instances',
        );

};

=head2 errors

=cut

template 'errors' => page {

        title is _('Strix errors');

        render_region(
                name => 'selected-instances',
                path => '/strix/selected-instances'
        );

        h2 { _('Name differences') }

        my $name_diff = A3C::SQL->new({ query => qq{
                select
                        instance,hreduorgurl,
                        _site_name,o
                from strix_instances
                join hr_edu_orgs on cn = instance
                where o != _site_name
        }});

        if ( $name_diff->count > 0 ) {

                table {
                        row {
                                th {}
                                th { _('Instance') }
                                th { _('Strix instance name') }
                                th { _('hrEduOrg.o') }
                        };
                        while ( my $row = $name_diff->next ) {
                                row {
                                        cell { show( 'instance-op', 'Create', '+', $row->instance ) }
                                        cell { $row->instance }
                                        cell { $row->_site_name }
                                        cell { $row->o }
                                }
                        }
                }
        
        } else {
                div { _("Can't find any instance of strix which has different name than data from LDAP") }
        }

};

=head2 instances

=cut

template 'instances' => page {

        title is _('Strix instances');

        my $sql = A3C::SQL->new({ query => qq{
                select
                        hrEduOrgUrl, o, l, postalAddress, telephoneNumber, facsimileTelephoneNumber
                from strix_instances
                join hr_edu_orgs on cn = instance
                order by l,o
        }});

        if ( $sql->count > 0 ) {

                table {
                        row {
                                th { _('hrEduOrgUrl') }
                                th { _('o') }
                                th { _('l') }
                                th { _('postalAddress') }
                                th { _('telephoneNumber') }
                                th { _('facsimileTelephoneNumber') }
                        };
                        while ( my $row = $sql->next ) {
                                row {
                                        cell { outs_raw '<a href="http://' . $row->hrEduOrgUrl . '">' . $row->hrEduOrgUrl . '</a>' }
                                        cell { $row->o }
                                        cell { $row->l }
                                        cell { $row->postalAddress }
                                        cell { $row->telephoneNumber }
                                        cell { $row->facsimileTelephoneNumber }
                                }
                        }
                }

                div { _("Found total of %1 strix instances", $sql->count) }

        } else {
                div { _("Can't find any strix instances") }
        }

};

=head2 sql

Execute SQL query on instance

=cut

template 'sql' => page {

        title is _('Execute SQL');

        render_region(
                name => 'selected-instances',
                path => '/strix/selected-instances'
        );

        render_region(
                name => 'execute-sql',
                path => '/strix/execute-sql',
        );

};

sub strix {
        my $instance = get('instance');
        return Strix->new({ instance => $instance });
}

sub strix_link {
        my ( $url, $label ) = @_;
        hyperlink(
                url => 'http://' . get('instance') . Jifty->config->app('strix')->{domain} . $url,
                label => $label || $url,
                target => 'strix',
        );
}

=head2 navigation

=cut

template 'navigation' => page {

        title is _('Site navigation');

        render_region(
                name => 'selected-instances',
                path => '/strix/selected-instances'
        );

        render_region(
                name => 'strix-site',
                path => '/strix/site'
        );

};

=head1 REGIONS

=head2 execute-sql

Execute SQL query on instance

=cut

template 'execute-sql' => sub {

        my $sql = get('sql') || Jifty->web->session->get('sql');
        warn ">>>> sql = $sql";
        my $instance = get('instance');
        warn ">>>> instance = $instance";

        my $action = new_action(
                class   => 'StrixSQL',
                moniker => 'strix-sql',
                sticky_on_success => 1,
                sticky_on_failure => 1,
                arguments => {
                        instance => $instance,
                        sql => $sql,
                },
        );

        form {
                render_action( $action, [ 'instance', 'sql' ] );
                form_submit( label => _('Execute SQL') );
        };

        if ( my $sql = $action->result->content('sql') ) {
                Jifty->web->session->set( sql => $sql->query );
                div { _('Found %1 results for %2', $sql->count, $instance ) }
                table {
                        row { map { th { $_ } } $sql->_column_names };
                        while (my $row = $sql->next) {
                                row {
                                        foreach my $col ( $sql->_column_names ) {
                                                cell { $row->$col }
                                        }
                                }
                        }
                }
        }
        warn ">>>> sql (at end) = ",Jifty->web->session->get('sql');
};

=head2 search-instances

=cut

template 'search-instances' => sub {

        h1 { _('Find instance') }

        my $action = new_action(
                class   => 'SearchStrixInstance',
                moniker => 'search-strix-instance',
                sticky_on_success => 1,
                sticky_on_failure => 1,
        );


        form {
                render_action( $action => [ 'instance_contains', '_site_name_contains' ] );
                form_submit( label => _('Search') );
        };

#       warn dump( $action->result->content );

        if ( my $search = $action->result->content('search') ) {
                div { _('Found %1 results', $search->count ) }
                table {
                        while (my $strix = $search->next) {
                                row {
                                        cell { show( 'instance-op', 'Create', '+', $strix->instance ) }
                                        cell { tt { $strix->instance } }
                                        cell { $strix->_site_name }
                                }
                        }
                }
        }

};

=head2 selected-instances

Show Selected instances for current user

=cut

template 'selected-instances' => sub {
        my $self = shift;

#       warn "## IN selected-instances ",dump( @_ );

        if ( my $op = get 'op' ) {
                my $op_instance = get 'op_instance';
                return unless $op_instance;
                warn "# selected-instances $op on $op_instance";

                my $a;

                if ( $op eq 'Create' ) {

                        $a = new_action(
                                class => $op . 'StrixInstanceSelection',
                                moniker => $op,
                                arguments => {
                                        instance => $op_instance,
                                        by_user => $self->current_user->id,
                                },
                        );

                } elsif ( $op eq 'Delete' ) {

                        my $strix = A3C::Model::StrixInstanceSelection->new;
                        $strix->load_by_cols( instance => $op_instance, by_user => $self->current_user->id );
                        warn "can't find instance $op_instance" unless $strix->id;
                        $a = $strix->as_delete_action;

                }
#               warn "# argument_values = ",dump( $a->argument_values );
                $a->run;

                if ( $a->result->error ) {
                        div {
                                { class is 'note error' }
                                $a->result->error;
                        }
                }

                set( op => '' );
        }

        my $selected = A3C::Model::StrixInstanceSelectionCollection->new;
        $selected->limit( column => 'by_user', value => Jifty->web->current_user->id );

        if ( $selected->count > 0 ) {

                my $instance = get('instance');
                warn "# selected-instances -- selected: $instance\n";

                div { _('%1 instances selected', $selected->count ) };
                table {
                        while (my $s = $selected->next) {
                                row {
                                        cell { tt {
                                                if ( $s->instance->instance eq $instance ) {
                                                        b { $instance }
                                                } else {
                                                        hyperlink(
                                                                url => '?instance=' . $s->instance->instance,
                                                                label => $s->instance->instance
                                                        )
                                                }
                                        } }
                                        cell { $s->instance->_site_name }
                                        cell { show( 'instance-op', 'Delete', '-', $s->instance->instance ) }
                                }
                        }
                }
        } else {
                div { _('No instances selected') }
        }
};

=head2 instance-op

Display button to add/remove instance from selection

  show( 'instance-op', 'Delete', '-', $strix->instace );

=cut

template 'instance-op' => sub {
        my $self = shift;

#       warn "# instance-op = ",dump( @_ );

        my ( $op, $label, $instance ) = @_;

        form {
                hyperlink(
                        label => $label,
                        onclick => {
                                refresh => 'selected-instances',
                                path => '/strix/selected-instances',
                                args => {
                                        op_instance => $instance,
                                        op => $op,
                                }
                        },
                );
        }

};

=head2 site

=cut

template 'site' => sub {

        my $action = new_action(
                class   => 'StrixSelectSite',
                moniker => 'strix-select-site',
        );

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

        warn "# argument_values = ", dump( $action->argument_values );

        if ( ! $action->argument_value('instance') ) {
                $action->argument_value( 'instance', get('instance') );
                warn "# run action with instance\n";
                $action->run;
        }

        my $magic = [
                { submit => $action, refresh_self => 1 },
                # this is basically a closure
                { refresh => 'selected-instances', path => '/strix/selected-instances', args => {
                        instance => { result_of => $action, name => 'instance' }
                } },
                { refresh => 'strix-site-layout', path => '/__jifty/empty' },
        ];

        form {
                render_param( $action, 'instance', onchange => $magic );
                render_param( $action, 'site_id', onchange => $magic );
                form_submit( label => _('Show navigation'), onclick => $magic );
        };

        warn "## select-site action ",dump( $action->result );

        render_region(
                name => 'layout',
                path => '/__jifty/empty',
        );

        if ( my $site_id = $action->result->content('site_id') ) {
                show('navigation-tree', $action->result->content('instance'), $site_id);
        }
};

=head2 layout

Shows layout for C<url>

=cut

template 'layout' => sub {

        my $url = get('url') || '/';
        my $category = strix->category( $url );
        my $layout = strix->layout( $url );

        h1 { $category->{naziv} }
        pre {
                dump( $layout );
        }

};

=head2 category

Show category data for C<url>

=cut

template 'category' => sub {

        my $url = get('url') || '/';
        my $category = strix->category( $url );

        h1 { $category->{naziv} }
        pre {
                dump( $category );
        }

};

=head1 PRIVATE TEMPLATES

=head2 navigation-tree-category

  show('navigation-tree-category',$kat_row);

=cut

private template 'navigation-tree-category' => sub {
        my $self = shift;
        #warn "## navigation-tree-category",dump( @_ );
        my $p = shift;
        hyperlink(
                onclick => {
                        region => 'strix-site-layout',  # FIXME do we have to hard-code region name here?
                        replace_with => '/strix/category',
                        args => {
                                url => $p->{url},
                                instance => get('instance'),
                        }
                },
                label => $p->{naziv},
        );
        outs_raw('&nbsp;');
        if ( $p->{type} eq 'category' ) {
                hyperlink(
#                               url => '/strix/layout?url=' . $p->{url} . ';instance=' . get('instance'),
                        onclick => {
                                region => 'strix-site-layout',  # FIXME do we have to hard-code region name here?
                                replace_with => '/strix/layout',
                                args => {
                                        url => $p->{url},
                                        instance => get('instance'),
                                }
                        },
                        label => _('layout'),
                        class => 'layout',
                );
        }
        outs_raw('&nbsp;');
        strix_link( $p->{url}, '>>' );
};

=head2 navigation-tree

  show('navigation-tree',$instance,$site_id);

=cut

private template 'navigation-tree' => sub {
        my $self = shift;
        my ( $instance, $site_id ) = @_;

        warn "## navigation-tree instance: $instance site_id: $site_id";

        set 'instance' => $instance;

        sub children {
                my $c = shift;
                return unless defined $c->{children};
                ul {
                        foreach my $p ( @{ $c->{children} } ) {
                                li {
                                        if ( defined( $p->{class} ) ) {
                                                { class is $p->{class} };
                                        }
                                        show( 'navigation-tree-category', $p );
                                        children( $p );
                                }
                        }
                }
        }

        my $strix = Strix->new({ instance => $instance });

        my $navigation = $strix->site_navigation( $site_id );
        #warn "## navigation = ",dump( $navigation );
        if ( $navigation ) {
                ul {
                        { class is 'navigation' };
                        foreach my $p ( @$navigation ) {
                                li {
                                        show( 'navigation-tree-category', $p );
                                        children( $p );
                                }
                        }
                }
        } else {
                div {
                        { class is 'note error' }
                        _('No navigation found for instance %1 site_id %2', $instance, $site_id)
                }

        }

};

1;
1	dpavlin	142	package A3C::View::Strix;
2
3			=head1 NAME
4
5			A3C::View::Strix
6
7			=head1 DESCRIPTION
8
9	dpavlin	174	Display information about Strix instances
10	dpavlin	142
11	dpavlin	157	=head1 TEMPLATES
12
13	dpavlin	142	=cut
14
15			use strict;
16			use warnings;
17
18			use Jifty::View::Declare -base;
19			use Data::Dump qw/dump/;
20
21	dpavlin	157	=head2 /
22
23	dpavlin	174	Display instaces search and some stats
24	dpavlin	157
25			=cut
26
27	dpavlin	142	template 'index.html' => page {
28
29	dpavlin	174	title is _('Strix instances');
30	dpavlin	153
31	dpavlin	174	my $orgs = A3C::Model::StrixInstanceCollection->new;
32	dpavlin	166	$orgs->unlimit;
33
34	dpavlin	174	div { _('Number of instances in Strix: %1', $orgs->count ) };
35	dpavlin	166
36	dpavlin	157	render_region(
37	dpavlin	174	name => 'selected-instances',
38			path => '/strix/selected-instances'
39	dpavlin	157	);
40
41			render_region(
42	dpavlin	174	name => 'search-instances',
43			path => '/strix/search-instances',
44	dpavlin	157	);
45
46	dpavlin	153	};
47
48	dpavlin	241	=head2 errors
49	dpavlin	157
50			=cut
51
52	dpavlin	241	template 'errors' => page {
53	dpavlin	153
54	dpavlin	241	title is _('Strix errors');
55	dpavlin	153
56	dpavlin	183	render_region(
57			name => 'selected-instances',
58			path => '/strix/selected-instances'
59			);
60
61	dpavlin	241	h2 { _('Name differences') }
62
63	dpavlin	142	my $name_diff = A3C::SQL->new({ query => qq{
64			select
65	dpavlin	174	instance,hreduorgurl,
66	dpavlin	142	_site_name,o
67	dpavlin	174	from strix_instances
68			join hr_edu_orgs on cn = instance
69	dpavlin	142	where o != _site_name
70			}});
71
72	dpavlin	166	if ( $name_diff->count > 0 ) {
73
74	dpavlin	142	table {
75			row {
76	dpavlin	183	th {}
77	dpavlin	174	th { _('Instance') }
78			th { _('Strix instance name') }
79	dpavlin	142	th { _('hrEduOrg.o') }
80			};
81			while ( my $row = $name_diff->next ) {
82			row {
83	dpavlin	183	cell { show( 'instance-op', 'Create', '+', $row->instance ) }
84			cell { $row->instance }
85	dpavlin	142	cell { $row->_site_name }
86			cell { $row->o }
87			}
88			}
89			}
90	dpavlin	166
91			} else {
92	dpavlin	174	div { _("Can't find any instance of strix which has different name than data from LDAP") }
93	dpavlin	142	}
94
95			};
96
97	dpavlin	234	=head2 instances
98
99			=cut
100
101			template 'instances' => page {
102
103			title is _('Strix instances');
104
105			my $sql = A3C::SQL->new({ query => qq{
106			select
107			hrEduOrgUrl, o, l, postalAddress, telephoneNumber, facsimileTelephoneNumber
108			from strix_instances
109			join hr_edu_orgs on cn = instance
110			order by l,o
111			}});
112
113			if ( $sql->count > 0 ) {
114
115			table {
116			row {
117			th { _('hrEduOrgUrl') }
118			th { _('o') }
119			th { _('l') }
120			th { _('postalAddress') }
121			th { _('telephoneNumber') }
122			th { _('facsimileTelephoneNumber') }
123			};
124			while ( my $row = $sql->next ) {
125			row {
126	dpavlin	242	cell { outs_raw '<a href="http://' . $row->hrEduOrgUrl . '">' . $row->hrEduOrgUrl . '</a>' }
127	dpavlin	234	cell { $row->o }
128			cell { $row->l }
129			cell { $row->postalAddress }
130			cell { $row->telephoneNumber }
131			cell { $row->facsimileTelephoneNumber }
132			}
133			}
134			}
135
136			div { _("Found total of %1 strix instances", $sql->count) }
137
138			} else {
139			div { _("Can't find any strix instances") }
140			}
141
142			};
143
144	dpavlin	161	=head2 sql
145
146	dpavlin	174	Execute SQL query on instance
147	dpavlin	161
148			=cut
149
150			template 'sql' => page {
151
152			title is _('Execute SQL');
153
154	dpavlin	166	render_region(
155	dpavlin	174	name => 'selected-instances',
156			path => '/strix/selected-instances'
157	dpavlin	166	);
158
159			render_region(
160			name => 'execute-sql',
161			path => '/strix/execute-sql',
162			);
163
164			};
165
166	dpavlin	174	sub strix {
167	dpavlin	186	my $instance = get('instance');
168	dpavlin	174	return Strix->new({ instance => $instance });
169			}
170
171	dpavlin	187	sub strix_link {
172			my ( $url, $label ) = @_;
173			hyperlink(
174	dpavlin	239	url => 'http://' . get('instance') . Jifty->config->app('strix')->{domain} . $url,
175	dpavlin	187	label => $label \|\| $url,
176			target => 'strix',
177			);
178			}
179
180	dpavlin	211	=head2 navigation
181
182			=cut
183
184	dpavlin	205	template 'navigation' => page {
185	dpavlin	172
186	dpavlin	197	title is _('Site navigation');
187	dpavlin	172
188	dpavlin	183	render_region(
189	dpavlin	200	name => 'selected-instances',
190			path => '/strix/selected-instances'
191			);
192
193			render_region(
194	dpavlin	211	name => 'strix-site',
195			path => '/strix/site'
196	dpavlin	183	);
197
198	dpavlin	172	};
199
200	dpavlin	166	=head1 REGIONS
201
202			=head2 execute-sql
203
204	dpavlin	174	Execute SQL query on instance
205	dpavlin	166
206			=cut
207
208			template 'execute-sql' => sub {
209
210	dpavlin	221	my $sql = get('sql') \|\| Jifty->web->session->get('sql');
211			warn ">>>> sql = $sql";
212			my $instance = get('instance');
213			warn ">>>> instance = $instance";
214
215	dpavlin	161	my $action = new_action(
216			class => 'StrixSQL',
217			moniker => 'strix-sql',
218			sticky_on_success => 1,
219			sticky_on_failure => 1,
220	dpavlin	166	arguments => {
221	dpavlin	221	instance => $instance,
222			sql => $sql,
223			},
224	dpavlin	161	);
225
226			form {
227	dpavlin	221	render_action( $action, [ 'instance', 'sql' ] );
228	dpavlin	161	form_submit( label => _('Execute SQL') );
229			};
230
231			if ( my $sql = $action->result->content('sql') ) {
232	dpavlin	221	Jifty->web->session->set( sql => $sql->query );
233			div { _('Found %1 results for %2', $sql->count, $instance ) }
234	dpavlin	161	table {
235			row { map { th { $_ } } $sql->_column_names };
236			while (my $row = $sql->next) {
237			row {
238			foreach my $col ( $sql->_column_names ) {
239			cell { $row->$col }
240			}
241			}
242			}
243			}
244			}
245	dpavlin	221	warn ">>>> sql (at end) = ",Jifty->web->session->get('sql');
246	dpavlin	161	};
247
248	dpavlin	174	=head2 search-instances
249	dpavlin	157
250			=cut
251
252	dpavlin	174	template 'search-instances' => sub {
253	dpavlin	157
254	dpavlin	174	h1 { _('Find instance') }
255	dpavlin	157
256			my $action = new_action(
257	dpavlin	174	class => 'SearchStrixInstance',
258			moniker => 'search-strix-instance',
259	dpavlin	157	sticky_on_success => 1,
260			sticky_on_failure => 1,
261			);
262
263
264			form {
265	dpavlin	174	render_action( $action => [ 'instance_contains', '_site_name_contains' ] );
266	dpavlin	157	form_submit( label => _('Search') );
267			};
268
269			# warn dump( $action->result->content );
270
271			if ( my $search = $action->result->content('search') ) {
272			div { _('Found %1 results', $search->count ) }
273			table {
274			while (my $strix = $search->next) {
275			row {
276	dpavlin	189	cell { show( 'instance-op', 'Create', '+', $strix->instance ) }
277	dpavlin	174	cell { tt { $strix->instance } }
278	dpavlin	157	cell { $strix->_site_name }
279			}
280			}
281			}
282			}
283
284			};
285
286	dpavlin	174	=head2 selected-instances
287	dpavlin	157
288	dpavlin	174	Show Selected instances for current user
289	dpavlin	157
290			=cut
291
292	dpavlin	174	template 'selected-instances' => sub {
293	dpavlin	157	my $self = shift;
294
295	dpavlin	186	# warn "## IN selected-instances ",dump( @_ );
296	dpavlin	157
297			if ( my $op = get 'op' ) {
298	dpavlin	211	my $op_instance = get 'op_instance';
299			return unless $op_instance;
300	dpavlin	186	warn "# selected-instances $op on $op_instance";
301	dpavlin	157
302			my $a;
303
304			if ( $op eq 'Create' ) {
305
306			$a = new_action(
307	dpavlin	174	class => $op . 'StrixInstanceSelection',
308	dpavlin	157	moniker => $op,
309			arguments => {
310	dpavlin	186	instance => $op_instance,
311	dpavlin	157	by_user => $self->current_user->id,
312			},
313			);
314
315			} elsif ( $op eq 'Delete' ) {
316
317	dpavlin	174	my $strix = A3C::Model::StrixInstanceSelection->new;
318	dpavlin	186	$strix->load_by_cols( instance => $op_instance, by_user => $self->current_user->id );
319			warn "can't find instance $op_instance" unless $strix->id;
320	dpavlin	157	$a = $strix->as_delete_action;
321
322			}
323	dpavlin	186	# warn "# argument_values = ",dump( $a->argument_values );
324	dpavlin	157	$a->run;
325	dpavlin	186
326			if ( $a->result->error ) {
327			div {
328			{ class is 'note error' }
329			$a->result->error;
330			}
331			}
332
333			set( op => '' );
334	dpavlin	157	}
335
336	dpavlin	174	my $selected = A3C::Model::StrixInstanceSelectionCollection->new;
337	dpavlin	157	$selected->limit( column => 'by_user', value => Jifty->web->current_user->id );
338
339			if ( $selected->count > 0 ) {
340
341	dpavlin	186	my $instance = get('instance');
342	dpavlin	200	warn "# selected-instances -- selected: $instance\n";
343	dpavlin	186
344	dpavlin	183	div { _('%1 instances selected', $selected->count ) };
345	dpavlin	157	table {
346			while (my $s = $selected->next) {
347			row {
348	dpavlin	186	cell { tt {
349			if ( $s->instance->instance eq $instance ) {
350			b { $instance }
351			} else {
352			hyperlink(
353			url => '?instance=' . $s->instance->instance,
354			label => $s->instance->instance
355			)
356			}
357	dpavlin	183	} }
358			cell { $s->instance->_site_name }
359			cell { show( 'instance-op', 'Delete', '-', $s->instance->instance ) }
360	dpavlin	157	}
361			}
362			}
363			} else {
364	dpavlin	174	div { _('No instances selected') }
365	dpavlin	157	}
366			};
367
368	dpavlin	174	=head2 instance-op
369	dpavlin	157
370	dpavlin	174	Display button to add/remove instance from selection
371	dpavlin	157
372	dpavlin	174	show( 'instance-op', 'Delete', '-', $strix->instace );
373	dpavlin	157
374			=cut
375
376	dpavlin	174	template 'instance-op' => sub {
377	dpavlin	157	my $self = shift;
378
379	dpavlin	186	# warn "# instance-op = ",dump( @_ );
380	dpavlin	157
381	dpavlin	174	my ( $op, $label, $instance ) = @_;
382	dpavlin	157
383			form {
384			hyperlink(
385			label => $label,
386			onclick => {
387	dpavlin	174	refresh => 'selected-instances',
388			path => '/strix/selected-instances',
389	dpavlin	157	args => {
390	dpavlin	186	op_instance => $instance,
391	dpavlin	157	op => $op,
392			}
393			},
394			);
395			}
396
397			};
398
399	dpavlin	211	=head2 site
400	dpavlin	157
401	dpavlin	197	=cut
402
403	dpavlin	211	template 'site' => sub {
404	dpavlin	197
405			my $action = new_action(
406			class => 'StrixSelectSite',
407			moniker => 'strix-select-site',
408			);
409
410	dpavlin	200	warn "# action = ", dump( $action );
411	dpavlin	197
412	dpavlin	200	warn "# argument_values = ", dump( $action->argument_values );
413
414			if ( ! $action->argument_value('instance') ) {
415			$action->argument_value( 'instance', get('instance') );
416			warn "# run action with instance\n";
417			$action->run;
418			}
419
420			my $magic = [
421			{ submit => $action, refresh_self => 1 },
422			# this is basically a closure
423			{ refresh => 'selected-instances', path => '/strix/selected-instances', args => {
424			instance => { result_of => $action, name => 'instance' }
425	dpavlin	211	} },
426			{ refresh => 'strix-site-layout', path => '/__jifty/empty' },
427	dpavlin	200	];
428
429	dpavlin	197	form {
430	dpavlin	200	render_param( $action, 'instance', onchange => $magic );
431			render_param( $action, 'site_id', onchange => $magic );
432			form_submit( label => _('Show navigation'), onclick => $magic );
433	dpavlin	197	};
434
435			warn "## select-site action ",dump( $action->result );
436
437	dpavlin	211	render_region(
438			name => 'layout',
439			path => '/__jifty/empty',
440			);
441
442	dpavlin	197	if ( my $site_id = $action->result->content('site_id') ) {
443	dpavlin	214	show('navigation-tree', $action->result->content('instance'), $site_id);
444	dpavlin	197	}
445			};
446
447	dpavlin	217	=head2 layout
448
449			Shows layout for C<url>
450
451			=cut
452
453			template 'layout' => sub {
454
455			my $url = get('url') \|\| '/';
456			my $category = strix->category( $url );
457			my $layout = strix->layout( $url );
458
459			h1 { $category->{naziv} }
460			pre {
461			dump( $layout );
462			}
463
464			};
465
466			=head2 category
467
468			Show category data for C<url>
469
470			=cut
471
472			template 'category' => sub {
473
474			my $url = get('url') \|\| '/';
475			my $category = strix->category( $url );
476
477			h1 { $category->{naziv} }
478			pre {
479			dump( $category );
480			}
481
482			};
483
484	dpavlin	197	=head1 PRIVATE TEMPLATES
485
486	dpavlin	214	=head2 navigation-tree-category
487	dpavlin	197
488	dpavlin	214	show('navigation-tree-category',$kat_row);
489	dpavlin	197
490			=cut
491
492	dpavlin	214	private template 'navigation-tree-category' => sub {
493	dpavlin	211	my $self = shift;
494	dpavlin	214	#warn "## navigation-tree-category",dump( @_ );
495	dpavlin	211	my $p = shift;
496	dpavlin	217	hyperlink(
497			onclick => {
498			region => 'strix-site-layout', # FIXME do we have to hard-code region name here?
499			replace_with => '/strix/category',
500			args => {
501			url => $p->{url},
502			instance => get('instance'),
503			}
504			},
505			label => $p->{naziv},
506			);
507			outs_raw(' ');
508	dpavlin	211	if ( $p->{type} eq 'category' ) {
509			hyperlink(
510	dpavlin	217	# url => '/strix/layout?url=' . $p->{url} . ';instance=' . get('instance'),
511	dpavlin	211	onclick => {
512			region => 'strix-site-layout', # FIXME do we have to hard-code region name here?
513			replace_with => '/strix/layout',
514			args => {
515			url => $p->{url},
516			instance => get('instance'),
517			}
518			},
519			label => _('layout'),
520			class => 'layout',
521			);
522			}
523	dpavlin	217	outs_raw(' ');
524			strix_link( $p->{url}, '>>' );
525	dpavlin	211	};
526
527	dpavlin	214	=head2 navigation-tree
528
529			show('navigation-tree',$instance,$site_id);
530
531			=cut
532
533			private template 'navigation-tree' => sub {
534	dpavlin	197	my $self = shift;
535			my ( $instance, $site_id ) = @_;
536
537	dpavlin	217	warn "## navigation-tree instance: $instance site_id: $site_id";
538	dpavlin	197
539			set 'instance' => $instance;
540
541			sub children {
542			my $c = shift;
543			return unless defined $c->{children};
544			ul {
545			foreach my $p ( @{ $c->{children} } ) {
546			li {
547	dpavlin	212	if ( defined( $p->{class} ) ) {
548			{ class is $p->{class} };
549			}
550	dpavlin	214	show( 'navigation-tree-category', $p );
551	dpavlin	197	children( $p );
552			}
553			}
554			}
555			}
556
557			my $strix = Strix->new({ instance => $instance });
558
559	dpavlin	214	my $navigation = $strix->site_navigation( $site_id );
560			#warn "## navigation = ",dump( $navigation );
561			if ( $navigation ) {
562	dpavlin	197	ul {
563	dpavlin	217	{ class is 'navigation' };
564	dpavlin	214	foreach my $p ( @$navigation ) {
565	dpavlin	197	li {
566	dpavlin	214	show( 'navigation-tree-category', $p );
567	dpavlin	197	children( $p );
568			}
569			}
570			}
571			} else {
572			div {
573			{ class is 'note error' }
574			_('No navigation found for instance %1 site_id %2', $instance, $site_id)
575			}
576
577			}
578
579			};
580
581	dpavlin	142	1;