lib/A3C/View.pm

package A3C::View;

use strict;
use warnings;

use Jifty::View::Declare -base;
use A3C::LDAP;
use A3C::SQL;

use Data::Dump qw/dump/;

private template 'menu' => sub {
        div {
                attr { id => "navigation" };
                Jifty->web->navigation->render_as_classical_menu;
        };
};


template '/' => page {

        h1 { _('Statistics') }

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

        dt { _('Number of schools in system') }
        dd { $orgs->count }

        my $people = A3C::Model::hrEduPersonCollection->new;
        $people->unlimit;

        dt { _('Number of persons in system') }
        dd { $people->count }

        my $by_towns = A3C::SQL->new({ query => qq{
                select count(uid),l
                from hr_edu_orgs
                inner join towns on towns.name = l
                group by l
                order by count desc
                limit 25
        }});

        dt { _('Top %1 towns by schools', $by_towns->count) }
        dd {
                ul {
                        while ( my $row = $by_towns->next ) {
                                li { outs_raw( $row->count, ' ', $row->l ) }
                        }
                }
        }

        my $by_county = A3C::SQL->new({ query => qq{
                select
                        count(uid) as schools,
                        county,
                        count(distinct municipality) as municipalities
                from hr_edu_orgs
                inner join towns on towns.name = l
                group by county
                order by schools desc
        }});

        dt { _('Schools by counties') }
        dd {
                table {
                        th { _('Schools') }
                        th { _('County') }
                        th { _('Municipalities') };
                        while ( my $row = $by_county->next ) {
                                row {
                                        cell { $row->schools }
                                        cell { $row->county }
                                        cell { $row->municipalities }
                                }
                        }
                }
        }
};


template 'ldap' => page {
        h1 { _('LDAP data about Schools in system') };
        my $ldap = A3C::LDAP->new;
        div {
                $ldap->search(
                        base    => 'dc=skole,dc=hr',
                        filter  => '(objectClass=hrEduOrg)',
                        sizelimit => 10,
                );
                while ( my $entry = $ldap->current_search->shift_entry ) {
                        #warn $entry->dump;
                        ul {
                                foreach my $attr ( $entry->attributes ) {
                                        li {
                                                tt { $attr }
                                                span { dump( $entry->get_value( $attr ) ) }
                                        }
                                }
                        }
                }
        }
};

template 'people' => page {
        
        h1 { _('Find people') }

        my $action = new_action(
                class   => 'SearchhrEduPerson',
                moniker => 'search-users',
                sticky_on_success => 1,
                sticky_on_failure => 1,
        );


        form {
                render_action( $action => [ 'uid_contains', 'cn_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 $user = $search->next) {
                                row {
                                        cell { $user->cn }
                                        cell { tt { $user->uid } }
                                        cell { tt { $user->hrEduPersonUniqueID } }
                                        cell { $user->hrEduPersonHomeOrg }
                                }
                        }
                }
        }

};

template 'sync' => page {

        h1 { _('Sync school from LDAP') }

        my $action = new_action(
                class   => 'SyncOrganization',
                moniker => 'sync-organization'
        );

        form {
                render_action( $action => [ 'org_uid' ] );
                form_submit( label => _('Sync Organization') );
        };

        if ( my $users = $action->result->content('synced-users') ) {
                ol {
                        while (my $user = $users->next) {
                                li {
                                        span { $user->cn }
                                        tt { { class is 'email' } '<' . $user->mail . '>' }
                                }
                        }
                }
        }

};

# mount other views
use A3C::View::Organization;

# we can't really use following form because Jifty would upper case first
# letter of model and try to find A3C::Model::HrEduOrg which doesn't exit!
#Jifty::View::Declare::CRUD->mount_view('hrEduOrg', 'A3C::View::Organization', '/organizations');
alias A3C::View::Organization under '/organizations', {
        object_type => 'hrEduOrg',
};

use A3C::View::Strix;
alias A3C::View::Strix under '/strix';

1;
1	dpavlin	37	package A3C::View;
2
3			use strict;
4			use warnings;
5
6			use Jifty::View::Declare -base;
7			use A3C::LDAP;
8	dpavlin	79	use A3C::SQL;
9	dpavlin	37
10			use Data::Dump qw/dump/;
11
12	dpavlin	165	private template 'menu' => sub {
13			div {
14			attr { id => "navigation" };
15			Jifty->web->navigation->render_as_classical_menu;
16			};
17			};
18
19
20	dpavlin	72	template '/' => page {
21	dpavlin	37
22	dpavlin	72	h1 { _('Statistics') }
23
24	dpavlin	120	my $orgs = A3C::Model::hrEduOrgCollection->new;
25	dpavlin	72	$orgs->unlimit;
26
27			dt { _('Number of schools in system') }
28			dd { $orgs->count }
29
30	dpavlin	120	my $people = A3C::Model::hrEduPersonCollection->new;
31	dpavlin	72	$people->unlimit;
32
33			dt { _('Number of persons in system') }
34			dd { $people->count }
35
36	dpavlin	83	my $by_towns = A3C::SQL->new({ query => qq{
37	dpavlin	79	select count(uid),l
38	dpavlin	120	from hr_edu_orgs
39	dpavlin	79	inner join towns on towns.name = l
40			group by l
41			order by count desc
42			limit 25
43			}});
44	dpavlin	72
45	dpavlin	83	dt { _('Top %1 towns by schools', $by_towns->count) }
46	dpavlin	72	dd {
47			ul {
48	dpavlin	83	while ( my $row = $by_towns->next ) {
49	dpavlin	79	li { outs_raw( $row->count, ' ', $row->l ) }
50	dpavlin	72	}
51			}
52			}
53
54	dpavlin	83	my $by_county = A3C::SQL->new({ query => qq{
55			select
56			count(uid) as schools,
57			county,
58			count(distinct municipality) as municipalities
59	dpavlin	120	from hr_edu_orgs
60	dpavlin	83	inner join towns on towns.name = l
61			group by county
62			order by schools desc
63			}});
64
65			dt { _('Schools by counties') }
66			dd {
67			table {
68			th { _('Schools') }
69			th { _('County') }
70			th { _('Municipalities') };
71			while ( my $row = $by_county->next ) {
72			row {
73			cell { $row->schools }
74			cell { $row->county }
75			cell { $row->municipalities }
76			}
77			}
78			}
79			}
80	dpavlin	72	};
81
82
83	dpavlin	71	template 'ldap' => page {
84			h1 { _('LDAP data about Schools in system') };
85	dpavlin	40	my $ldap = A3C::LDAP->new;
86	dpavlin	37	div {
87	dpavlin	40	$ldap->search(
88	dpavlin	37	base => 'dc=skole,dc=hr',
89			filter => '(objectClass=hrEduOrg)',
90			sizelimit => 10,
91			);
92	dpavlin	41	while ( my $entry = $ldap->current_search->shift_entry ) {
93	dpavlin	37	#warn $entry->dump;
94			ul {
95			foreach my $attr ( $entry->attributes ) {
96			li {
97			tt { $attr }
98	dpavlin	39	span { dump( $entry->get_value( $attr ) ) }
99	dpavlin	37	}
100			}
101			}
102			}
103			}
104			};
105
106	dpavlin	71	template 'people' => page {
107
108			h1 { _('Find people') }
109	dpavlin	49
110			my $action = new_action(
111	dpavlin	122	class => 'SearchhrEduPerson',
112	dpavlin	71	moniker => 'search-users',
113			sticky_on_success => 1,
114			sticky_on_failure => 1,
115	dpavlin	49	);
116
117	dpavlin	71
118	dpavlin	49	form {
119			render_action( $action => [ 'uid_contains', 'cn_contains' ] );
120	dpavlin	155	form_submit( label => _('Search') );
121	dpavlin	49	};
122
123			# warn dump( $action->result->content );
124
125			if ( my $search = $action->result->content('search') ) {
126	dpavlin	155	div { _('Found %1 results', $search->count ) }
127	dpavlin	149	table {
128	dpavlin	49	while (my $user = $search->next) {
129	dpavlin	149	row {
130			cell { $user->cn }
131			cell { tt { $user->uid } }
132			cell { tt { $user->hrEduPersonUniqueID } }
133			cell { $user->hrEduPersonHomeOrg }
134	dpavlin	49	}
135			}
136			}
137			}
138
139			};
140
141	dpavlin	71	template 'sync' => page {
142	dpavlin	55
143	dpavlin	71	h1 { _('Sync school from LDAP') }
144
145	dpavlin	55	my $action = new_action(
146			class => 'SyncOrganization',
147			moniker => 'sync-organization'
148			);
149
150			form {
151	dpavlin	122	render_action( $action => [ 'org_uid' ] );
152	dpavlin	55	form_submit( label => _('Sync Organization') );
153			};
154
155			if ( my $users = $action->result->content('synced-users') ) {
156			ol {
157			while (my $user = $users->next) {
158			li {
159			span { $user->cn }
160	dpavlin	57	tt { { class is 'email' } '<' . $user->mail . '>' }
161	dpavlin	55	}
162			}
163			}
164			}
165
166			};
167	dpavlin	125
168			# mount other views
169			use A3C::View::Organization;
170
171			# we can't really use following form because Jifty would upper case first
172			# letter of model and try to find A3C::Model::HrEduOrg which doesn't exit!
173			#Jifty::View::Declare::CRUD->mount_view('hrEduOrg', 'A3C::View::Organization', '/organizations');
174			alias A3C::View::Organization under '/organizations', {
175			object_type => 'hrEduOrg',
176			};
177
178	dpavlin	142	use A3C::View::Strix;
179			alias A3C::View::Strix under '/strix';
180
181	dpavlin	125	1;